unit DocxMLUnitDecorator;
interface
uses DocxML, TSSafeUnitConverter;

type PropertiesUnitDecorator = class(Properties)
public
    function Create(_obj: Properties);
    function GetObject();
    function Convert();
private
    object_: Properties;
end;

type DocumentUnitDecorator = class(Document)
public
    function Create(_obj: Document);
    function GetObject();
    function Convert();
private
    object_: Document;
end;

type BodyUnitDecorator = class(Body)
public
    function Create(_obj: Body);
    function GetObject();
    function Convert();
private
    object_: Body;
end;

type PUnitDecorator = class(P)
public
    function Create(_obj: P);
    function GetObject();
    function Convert();
private
    object_: P;
end;

type FldSimpleUnitDecorator = class(FldSimple)
public
    function Create(_obj: FldSimple);
    function GetObject();
    function Convert();
private
    object_: FldSimple;
end;

type CommentRangeUnitDecorator = class(CommentRange)
public
    function Create(_obj: CommentRange);
    function GetObject();
    function Convert();
private
    object_: CommentRange;
end;

type HyperLinkUnitDecorator = class(HyperLink)
public
    function Create(_obj: HyperLink);
    function GetObject();
    function Convert();
private
    object_: HyperLink;
end;

type BookmarkUnitDecorator = class(Bookmark)
public
    function Create(_obj: Bookmark);
    function GetObject();
    function Convert();
private
    object_: Bookmark;
end;

type PPrUnitDecorator = class(PPr)
public
    function Create(_obj: PPr);
    function GetObject();
    function Convert();
private
    object_: PPr;
end;

type PBdrUnitDecorator = class(PBdr)
public
    function Create(_obj: PBdr);
    function GetObject();
    function Convert();
private
    object_: PBdr;
end;

type FramePrUnitDecorator = class(FramePr)
public
    function Create(_obj: FramePr);
    function GetObject();
    function Convert();
private
    object_: FramePr;
end;

type PBorderUnitDecorator = class(PBorder)
public
    function Create(_obj: PBorder);
    function GetObject();
    function Convert();
private
    object_: PBorder;
end;

type TabsUnitDecorator = class(Tabs)
public
    function Create(_obj: Tabs);
    function GetObject();
    function Convert();
private
    object_: Tabs;
end;

type TabUnitDecorator = class(Tab)
public
    function Create(_obj: Tab);
    function GetObject();
    function Convert();
private
    object_: Tab;
end;

type NumPrUnitDecorator = class(NumPr)
public
    function Create(_obj: NumPr);
    function GetObject();
    function Convert();
private
    object_: NumPr;
end;

type IndUnitDecorator = class(Ind)
public
    function Create(_obj: Ind);
    function GetObject();
    function Convert();
private
    object_: Ind;
end;

type SpacingUnitDecorator = class(Spacing)
public
    function Create(_obj: Spacing);
    function GetObject();
    function Convert();
private
    object_: Spacing;
end;

type RPrUnitDecorator = class(RPr)
public
    function Create(_obj: RPr);
    function GetObject();
    function Convert();
private
    object_: RPr;
end;

type ShdUnitDecorator = class(Shd)
public
    function Create(_obj: Shd);
    function GetObject();
    function Convert();
private
    object_: Shd;
end;

type HighlightUnitDecorator = class(Highlight)
public
    function Create(_obj: Highlight);
    function GetObject();
    function Convert();
private
    object_: Highlight;
end;

type FitTextUnitDecorator = class(FitText)
public
    function Create(_obj: FitText);
    function GetObject();
    function Convert();
private
    object_: FitText;
end;

type EastAsianLayoutUnitDecorator = class(EastAsianLayout)
public
    function Create(_obj: EastAsianLayout);
    function GetObject();
    function Convert();
private
    object_: EastAsianLayout;
end;

type DelUnitDecorator = class(Del)
public
    function Create(_obj: Del);
    function GetObject();
    function Convert();
private
    object_: Del;
end;

type BdrUnitDecorator = class(Bdr)
public
    function Create(_obj: Bdr);
    function GetObject();
    function Convert();
private
    object_: Bdr;
end;

type RFontsUnitDecorator = class(RFonts)
public
    function Create(_obj: RFonts);
    function GetObject();
    function Convert();
private
    object_: RFonts;
end;

type SzCsUnitDecorator = class(SzCs)
public
    function Create(_obj: SzCs);
    function GetObject();
    function Convert();
private
    object_: SzCs;
end;

type SzUnitDecorator = class(Sz)
public
    function Create(_obj: Sz);
    function GetObject();
    function Convert();
private
    object_: Sz;
end;

type PureValUnitDecorator = class(PureVal)
public
    function Create(_obj: PureVal);
    function GetObject();
    function Convert();
private
    object_: PureVal;
end;

type PureWValUnitDecorator = class(PureWVal)
public
    function Create(_obj: PureWVal);
    function GetObject();
    function Convert();
private
    object_: PureWVal;
end;

type ColorUnitDecorator = class(Color)
public
    function Create(_obj: Color);
    function GetObject();
    function Convert();
private
    object_: Color;
end;

type LangUnitDecorator = class(Lang)
public
    function Create(_obj: Lang);
    function GetObject();
    function Convert();
private
    object_: Lang;
end;

type RUnitDecorator = class(R)
public
    function Create(_obj: R);
    function GetObject();
    function Convert();
private
    object_: R;
end;

type CommentReferenceUnitDecorator = class(CommentReference)
public
    function Create(_obj: CommentReference);
    function GetObject();
    function Convert();
private
    object_: CommentReference;
end;

type ObjectUnitDecorator = class(Object)
public
    function Create(_obj: Object);
    function GetObject();
    function Convert();
private
    object_: Object;
end;

type FootnoteReferenceUnitDecorator = class(FootnoteReference)
public
    function Create(_obj: FootnoteReference);
    function GetObject();
    function Convert();
private
    object_: FootnoteReference;
end;

type FldCharUnitDecorator = class(FldChar)
public
    function Create(_obj: FldChar);
    function GetObject();
    function Convert();
private
    object_: FldChar;
end;

type InstrTextUnitDecorator = class(InstrText)
public
    function Create(_obj: InstrText);
    function GetObject();
    function Convert();
private
    object_: InstrText;
end;

type BrUnitDecorator = class(Br)
public
    function Create(_obj: Br);
    function GetObject();
    function Convert();
private
    object_: Br;
end;

type TxbxContentUnitDecorator = class(TxbxContent)
public
    function Create(_obj: TxbxContent);
    function GetObject();
    function Convert();
private
    object_: TxbxContent;
end;

type DrawingUnitDecorator = class(Drawing)
public
    function Create(_obj: Drawing);
    function GetObject();
    function Convert();
private
    object_: Drawing;
end;

type TUnitDecorator = class(T)
public
    function Create(_obj: T);
    function GetObject();
    function Convert();
private
    object_: T;
end;

type TblUnitDecorator = class(Tbl)
public
    function Create(_obj: Tbl);
    function GetObject();
    function Convert();
private
    object_: Tbl;
end;

type TblPrUnitDecorator = class(TblPr)
public
    function Create(_obj: TblPr);
    function GetObject();
    function Convert();
private
    object_: TblPr;
end;

type TblCellSpacingUnitDecorator = class(TblCellSpacing)
public
    function Create(_obj: TblCellSpacing);
    function GetObject();
    function Convert();
private
    object_: TblCellSpacing;
end;

type TblWUnitDecorator = class(TblW)
public
    function Create(_obj: TblW);
    function GetObject();
    function Convert();
private
    object_: TblW;
end;

type TblLayoutUnitDecorator = class(TblLayout)
public
    function Create(_obj: TblLayout);
    function GetObject();
    function Convert();
private
    object_: TblLayout;
end;

type TblLookUnitDecorator = class(TblLook)
public
    function Create(_obj: TblLook);
    function GetObject();
    function Convert();
private
    object_: TblLook;
end;

type TblBordersUnitDecorator = class(TblBorders)
public
    function Create(_obj: TblBorders);
    function GetObject();
    function Convert();
private
    object_: TblBorders;
end;

type TblBorderUnitDecorator = class(TblBorder)
public
    function Create(_obj: TblBorder);
    function GetObject();
    function Convert();
private
    object_: TblBorder;
end;

type TblGridUnitDecorator = class(TblGrid)
public
    function Create(_obj: TblGrid);
    function GetObject();
    function Convert();
private
    object_: TblGrid;
end;

type GridColUnitDecorator = class(GridCol)
public
    function Create(_obj: GridCol);
    function GetObject();
    function Convert();
private
    object_: GridCol;
end;

type TrUnitDecorator = class(Tr)
public
    function Create(_obj: Tr);
    function GetObject();
    function Convert();
private
    object_: Tr;
end;

type TrPrUnitDecorator = class(TrPr)
public
    function Create(_obj: TrPr);
    function GetObject();
    function Convert();
private
    object_: TrPr;
end;

type InsUnitDecorator = class(Ins)
public
    function Create(_obj: Ins);
    function GetObject();
    function Convert();
private
    object_: Ins;
end;

type CnfStyleUnitDecorator = class(CnfStyle)
public
    function Create(_obj: CnfStyle);
    function GetObject();
    function Convert();
private
    object_: CnfStyle;
end;

type TrHeightUnitDecorator = class(TrHeight)
public
    function Create(_obj: TrHeight);
    function GetObject();
    function Convert();
private
    object_: TrHeight;
end;

type TcUnitDecorator = class(Tc)
public
    function Create(_obj: Tc);
    function GetObject();
    function Convert();
private
    object_: Tc;
end;

type TcPrUnitDecorator = class(TcPr)
public
    function Create(_obj: TcPr);
    function GetObject();
    function Convert();
private
    object_: TcPr;
end;

type TcBordersUnitDecorator = class(TcBorders)
public
    function Create(_obj: TcBorders);
    function GetObject();
    function Convert();
private
    object_: TcBorders;
end;

type TcBorderUnitDecorator = class(TcBorder)
public
    function Create(_obj: TcBorder);
    function GetObject();
    function Convert();
private
    object_: TcBorder;
end;

type GridSpanUnitDecorator = class(GridSpan)
public
    function Create(_obj: GridSpan);
    function GetObject();
    function Convert();
private
    object_: GridSpan;
end;

type SdtUnitDecorator = class(Sdt)
public
    function Create(_obj: Sdt);
    function GetObject();
    function Convert();
private
    object_: Sdt;
end;

type SdtPrUnitDecorator = class(SdtPr)
public
    function Create(_obj: SdtPr);
    function GetObject();
    function Convert();
private
    object_: SdtPr;
end;

type DocPartObjUnitDecorator = class(DocPartObj)
public
    function Create(_obj: DocPartObj);
    function GetObject();
    function Convert();
private
    object_: DocPartObj;
end;

type SdtEndPrUnitDecorator = class(SdtEndPr)
public
    function Create(_obj: SdtEndPr);
    function GetObject();
    function Convert();
private
    object_: SdtEndPr;
end;

type SdtContentUnitDecorator = class(SdtContent)
public
    function Create(_obj: SdtContent);
    function GetObject();
    function Convert();
private
    object_: SdtContent;
end;

type SectPrUnitDecorator = class(SectPr)
public
    function Create(_obj: SectPr);
    function GetObject();
    function Convert();
private
    object_: SectPr;
end;

type ReferenceUnitDecorator = class(Reference)
public
    function Create(_obj: Reference);
    function GetObject();
    function Convert();
private
    object_: Reference;
end;

type PgNumTypeUnitDecorator = class(PgNumType)
public
    function Create(_obj: PgNumType);
    function GetObject();
    function Convert();
private
    object_: PgNumType;
end;

type PgSzUnitDecorator = class(PgSz)
public
    function Create(_obj: PgSz);
    function GetObject();
    function Convert();
private
    object_: PgSz;
end;

type PgMarUnitDecorator = class(PgMar)
public
    function Create(_obj: PgMar);
    function GetObject();
    function Convert();
private
    object_: PgMar;
end;

type ColsUnitDecorator = class(Cols)
public
    function Create(_obj: Cols);
    function GetObject();
    function Convert();
private
    object_: Cols;
end;

type ColUnitDecorator = class(Col)
public
    function Create(_obj: Col);
    function GetObject();
    function Convert();
private
    object_: Col;
end;

type DocGridUnitDecorator = class(DocGrid)
public
    function Create(_obj: DocGrid);
    function GetObject();
    function Convert();
private
    object_: DocGrid;
end;

type EndnotesUnitDecorator = class(Endnotes)
public
    function Create(_obj: Endnotes);
    function GetObject();
    function Convert();
private
    object_: Endnotes;
end;

type EndnoteUnitDecorator = class(Endnote)
public
    function Create(_obj: Endnote);
    function GetObject();
    function Convert();
private
    object_: Endnote;
end;

type FootnotesUnitDecorator = class(Footnotes)
public
    function Create(_obj: Footnotes);
    function GetObject();
    function Convert();
private
    object_: Footnotes;
end;

type FootnoteUnitDecorator = class(Footnote)
public
    function Create(_obj: Footnote);
    function GetObject();
    function Convert();
private
    object_: Footnote;
end;

type FontsUnitDecorator = class(Fonts)
public
    function Create(_obj: Fonts);
    function GetObject();
    function Convert();
private
    object_: Fonts;
end;

type FontUnitDecorator = class(Font)
public
    function Create(_obj: Font);
    function GetObject();
    function Convert();
private
    object_: Font;
end;

type SigUnitDecorator = class(Sig)
public
    function Create(_obj: Sig);
    function GetObject();
    function Convert();
private
    object_: Sig;
end;

type SettingsUnitDecorator = class(Settings)
public
    function Create(_obj: Settings);
    function GetObject();
    function Convert();
private
    object_: Settings;
end;

type ZoomUnitDecorator = class(Zoom)
public
    function Create(_obj: Zoom);
    function GetObject();
    function Convert();
private
    object_: Zoom;
end;

type HdrShapeDefaultsUnitDecorator = class(HdrShapeDefaults)
public
    function Create(_obj: HdrShapeDefaults);
    function GetObject();
    function Convert();
private
    object_: HdrShapeDefaults;
end;

type ShapeDefaultsUnitDecorator = class(ShapeDefaults)
public
    function Create(_obj: ShapeDefaults);
    function GetObject();
    function Convert();
private
    object_: ShapeDefaults;
end;

type FootnotePrUnitDecorator = class(FootnotePr)
public
    function Create(_obj: FootnotePr);
    function GetObject();
    function Convert();
private
    object_: FootnotePr;
end;

type EndnotePrUnitDecorator = class(EndnotePr)
public
    function Create(_obj: EndnotePr);
    function GetObject();
    function Convert();
private
    object_: EndnotePr;
end;

type CompatUnitDecorator = class(Compat)
public
    function Create(_obj: Compat);
    function GetObject();
    function Convert();
private
    object_: Compat;
end;

type CompatSettingUnitDecorator = class(CompatSetting)
public
    function Create(_obj: CompatSetting);
    function GetObject();
    function Convert();
private
    object_: CompatSetting;
end;

type RsidsUnitDecorator = class(Rsids)
public
    function Create(_obj: Rsids);
    function GetObject();
    function Convert();
private
    object_: Rsids;
end;

type ThemeFontLangUnitDecorator = class(ThemeFontLang)
public
    function Create(_obj: ThemeFontLang);
    function GetObject();
    function Convert();
private
    object_: ThemeFontLang;
end;

type ClrSchemeMappingUnitDecorator = class(ClrSchemeMapping)
public
    function Create(_obj: ClrSchemeMapping);
    function GetObject();
    function Convert();
private
    object_: ClrSchemeMapping;
end;

type ShapeDefaults2UnitDecorator = class(ShapeDefaults2)
public
    function Create(_obj: ShapeDefaults2);
    function GetObject();
    function Convert();
private
    object_: ShapeDefaults2;
end;

type ShapeLayoutUnitDecorator = class(ShapeLayout)
public
    function Create(_obj: ShapeLayout);
    function GetObject();
    function Convert();
private
    object_: ShapeLayout;
end;

type IdMapUnitDecorator = class(IdMap)
public
    function Create(_obj: IdMap);
    function GetObject();
    function Convert();
private
    object_: IdMap;
end;

type StylesUnitDecorator = class(Styles)
public
    function Create(_obj: Styles);
    function GetObject();
    function Convert();
private
    object_: Styles;
end;

type DocDefaultsUnitDecorator = class(DocDefaults)
public
    function Create(_obj: DocDefaults);
    function GetObject();
    function Convert();
private
    object_: DocDefaults;
end;

type RPrDefaultUnitDecorator = class(RPrDefault)
public
    function Create(_obj: RPrDefault);
    function GetObject();
    function Convert();
private
    object_: RPrDefault;
end;

type PPrDefaultUnitDecorator = class(PPrDefault)
public
    function Create(_obj: PPrDefault);
    function GetObject();
    function Convert();
private
    object_: PPrDefault;
end;

type LatenStylesUnitDecorator = class(LatenStyles)
public
    function Create(_obj: LatenStyles);
    function GetObject();
    function Convert();
private
    object_: LatenStyles;
end;

type LsdExceptionUnitDecorator = class(LsdException)
public
    function Create(_obj: LsdException);
    function GetObject();
    function Convert();
private
    object_: LsdException;
end;

type StyleUnitDecorator = class(Style)
public
    function Create(_obj: Style);
    function GetObject();
    function Convert();
private
    object_: Style;
end;

type TblStylePrUnitDecorator = class(TblStylePr)
public
    function Create(_obj: TblStylePr);
    function GetObject();
    function Convert();
private
    object_: TblStylePr;
end;

type TblIndUnitDecorator = class(TblInd)
public
    function Create(_obj: TblInd);
    function GetObject();
    function Convert();
private
    object_: TblInd;
end;

type TblCellMarUnitDecorator = class(TblCellMar)
public
    function Create(_obj: TblCellMar);
    function GetObject();
    function Convert();
private
    object_: TblCellMar;
end;

type WebSettingsUnitDecorator = class(WebSettings)
public
    function Create(_obj: WebSettings);
    function GetObject();
    function Convert();
private
    object_: WebSettings;
end;

type AlternateContentUnitDecorator = class(AlternateContent)
public
    function Create(_obj: AlternateContent);
    function GetObject();
    function Convert();
private
    object_: AlternateContent;
end;

type ChoiceUnitDecorator = class(Choice)
public
    function Create(_obj: Choice);
    function GetObject();
    function Convert();
private
    object_: Choice;
end;

type FallbackUnitDecorator = class(Fallback)
public
    function Create(_obj: Fallback);
    function GetObject();
    function Convert();
private
    object_: Fallback;
end;

type PictUnitDecorator = class(Pict)
public
    function Create(_obj: Pict);
    function GetObject();
    function Convert();
private
    object_: Pict;
end;

type ControlUnitDecorator = class(Control)
public
    function Create(_obj: Control);
    function GetObject();
    function Convert();
private
    object_: Control;
end;

type FtrUnitDecorator = class(Ftr)
public
    function Create(_obj: Ftr);
    function GetObject();
    function Convert();
private
    object_: Ftr;
end;

type HdrUnitDecorator = class(Hdr)
public
    function Create(_obj: Hdr);
    function GetObject();
    function Convert();
private
    object_: Hdr;
end;

type CommentsUnitDecorator = class(Comments)
public
    function Create(_obj: Comments);
    function GetObject();
    function Convert();
private
    object_: Comments;
end;

type CommentUnitDecorator = class(Comment)
public
    function Create(_obj: Comment);
    function GetObject();
    function Convert();
private
    object_: Comment;
end;

type NumberingUnitDecorator = class(Numbering)
public
    function Create(_obj: Numbering);
    function GetObject();
    function Convert();
private
    object_: Numbering;
end;

type NumUnitDecorator = class(Num)
public
    function Create(_obj: Num);
    function GetObject();
    function Convert();
private
    object_: Num;
end;

type AbstractNumUnitDecorator = class(AbstractNum)
public
    function Create(_obj: AbstractNum);
    function GetObject();
    function Convert();
private
    object_: AbstractNum;
end;

type LvlUnitDecorator = class(Lvl)
public
    function Create(_obj: Lvl);
    function GetObject();
    function Convert();
private
    object_: Lvl;
end;

implementation

function PropertiesUnitDecorator.Create(_obj: Properties);
begin
    class(Properties).Create();
    object_ := _obj;
    {self.}Convert();
end;

function PropertiesUnitDecorator.GetObject();
begin
    return object_;
end;

function PropertiesUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildTemplate) then
    if not ifnil(object_.XmlChildTotalTime) then
    if not ifnil(object_.XmlChildPages) then
    if not ifnil(object_.XmlChildWords) then
    if not ifnil(object_.XmlChildCharacters) then
    if not ifnil(object_.XmlChildApplication) then
    if not ifnil(object_.XmlChildDocSecurity) then
    if not ifnil(object_.XmlChildLines) then
    if not ifnil(object_.XmlChildParagraphs) then
    if not ifnil(object_.XmlChildScaleCrop) then
    if not ifnil(object_.XmlChildCompany) then
    if not ifnil(object_.XmlChildLinksUpToDate) then
    if not ifnil(object_.XmlChildCharactersWithSpaces) then
    if not ifnil(object_.XmlChildSharedDoc) then
    if not ifnil(object_.XmlChildHyperlinksChanged) then
    if not ifnil(object_.XmlChildAppVersion) then
    tslassigning := tslassigning_backup;
end;

function DocumentUnitDecorator.Create(_obj: Document);
begin
    class(Document).Create();
    object_ := _obj;
    {self.}Convert();
end;

function DocumentUnitDecorator.GetObject();
begin
    return object_;
end;

function DocumentUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrIgnorable) then
        {self.}Ignorable := object_.XmlAttrIgnorable.Value;
    if not ifnil(object_.XmlChildBody) then
        {self.}XmlChildBody := new BodyUnitDecorator(object_.XmlChildBody);
    tslassigning := tslassigning_backup;
end;

function BodyUnitDecorator.Create(_obj: Body);
begin
    class(Body).Create();
    object_ := _obj;
    {self.}Convert();
end;

function BodyUnitDecorator.GetObject();
begin
    return object_;
end;

function BodyUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    elems := object_.Ps();
    for _,elem in elems do
        {self.}AppendChild(new PUnitDecorator(elem));
    elems := object_.Tbls();
    for _,elem in elems do
        {self.}AppendChild(new TblUnitDecorator(elem));
    elems := object_.Sdts();
    for _,elem in elems do
        {self.}AppendChild(new SdtUnitDecorator(elem));
    if not ifnil(object_.XmlChildSectPr) then
        {self.}XmlChildSectPr := new SectPrUnitDecorator(object_.XmlChildSectPr);
    tslassigning := tslassigning_backup;
end;

function PUnitDecorator.Create(_obj: P);
begin
    class(P).Create();
    object_ := _obj;
    {self.}Convert();
end;

function PUnitDecorator.GetObject();
begin
    return object_;
end;

function PUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrParaId) then
        {self.}ParaId := object_.XmlAttrParaId.Value;
    if not ifnil(object_.XmlAttrTextId) then
        {self.}TextId := object_.XmlAttrTextId.Value;
    if not ifnil(object_.XmlAttrRsidR) then
        {self.}RsidR := object_.XmlAttrRsidR.Value;
    if not ifnil(object_.XmlAttrRsidRPr) then
        {self.}RsidRPr := object_.XmlAttrRsidRPr.Value;
    if not ifnil(object_.XmlAttrRsidRDefault) then
        {self.}RsidRDefault := object_.XmlAttrRsidRDefault.Value;
    if not ifnil(object_.XmlAttrRsidP) then
        {self.}RsidP := object_.XmlAttrRsidP.Value;
    if not ifnil(object_.XmlChildPPr) then
        {self.}XmlChildPPr := new PPrUnitDecorator(object_.XmlChildPPr);
    elems := object_.Sdts();
    for _,elem in elems do
        {self.}AppendChild(new SdtUnitDecorator(elem));
    elems := object_.Rs();
    for _,elem in elems do
        {self.}AppendChild(new RUnitDecorator(elem));
    elems := object_.CommentRangeStarts();
    for _,elem in elems do
        {self.}AppendChild(new CommentRangeUnitDecorator(elem));
    elems := object_.CommentRangeEnds();
    for _,elem in elems do
        {self.}AppendChild(new CommentRangeUnitDecorator(elem));
    elems := object_.BookmarkStarts();
    for _,elem in elems do
        {self.}AppendChild(new BookmarkUnitDecorator(elem));
    elems := object_.BookmarkEnds();
    for _,elem in elems do
        {self.}AppendChild(new BookmarkUnitDecorator(elem));
    elems := object_.Hyperlinks();
    for _,elem in elems do
        {self.}AppendChild(new HyperLinkUnitDecorator(elem));
    elems := object_.FldSimples();
    for _,elem in elems do
        {self.}AppendChild(new FldSimpleUnitDecorator(elem));
    if not ifnil(object_.XmlChildOMathPara) then
        {self.}XmlChildOMathPara := new OMathParaUnitDecorator(object_.XmlChildOMathPara);
    if not ifnil(object_.XmlChildOMath) then
        {self.}XmlChildOMath := new OMathUnitDecorator(object_.XmlChildOMath);
    if not ifnil(object_.XmlChildIns) then
        {self.}XmlChildIns := new InsUnitDecorator(object_.XmlChildIns);
    if not ifnil(object_.XmlChildDel) then
        {self.}XmlChildDel := new DelUnitDecorator(object_.XmlChildDel);
    tslassigning := tslassigning_backup;
end;

function FldSimpleUnitDecorator.Create(_obj: FldSimple);
begin
    class(FldSimple).Create();
    object_ := _obj;
    {self.}Convert();
end;

function FldSimpleUnitDecorator.GetObject();
begin
    return object_;
end;

function FldSimpleUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrDirty) then
        {self.}Dirty := object_.XmlAttrDirty.Value;
    if not ifnil(object_.XmlAttrFldLock) then
        {self.}FldLock := object_.XmlAttrFldLock.Value;
    if not ifnil(object_.XmlAttrInstr) then
        {self.}Instr := object_.XmlAttrInstr.Value;
    elems := object_.Rs();
    for _,elem in elems do
        {self.}AppendChild(new RUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function CommentRangeUnitDecorator.Create(_obj: CommentRange);
begin
    class(CommentRange).Create();
    object_ := _obj;
    {self.}Convert();
end;

function CommentRangeUnitDecorator.GetObject();
begin
    return object_;
end;

function CommentRangeUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrId) then
        {self.}Id := object_.XmlAttrId.Value;
    tslassigning := tslassigning_backup;
end;

function HyperLinkUnitDecorator.Create(_obj: HyperLink);
begin
    class(HyperLink).Create();
    object_ := _obj;
    {self.}Convert();
end;

function HyperLinkUnitDecorator.GetObject();
begin
    return object_;
end;

function HyperLinkUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrAnchor) then
        {self.}Anchor := object_.XmlAttrAnchor.Value;
    if not ifnil(object_.XmlAttrId) then
        {self.}Id := object_.XmlAttrId.Value;
    if not ifnil(object_.XmlAttrHistory) then
        {self.}History := object_.XmlAttrHistory.Value;
    elems := object_.Rs();
    for _,elem in elems do
        {self.}AppendChild(new RUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function BookmarkUnitDecorator.Create(_obj: Bookmark);
begin
    class(Bookmark).Create();
    object_ := _obj;
    {self.}Convert();
end;

function BookmarkUnitDecorator.GetObject();
begin
    return object_;
end;

function BookmarkUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrName) then
        {self.}Name := object_.XmlAttrName.Value;
    if not ifnil(object_.XmlAttrId) then
        {self.}Id := object_.XmlAttrId.Value;
    tslassigning := tslassigning_backup;
end;

function PPrUnitDecorator.Create(_obj: PPr);
begin
    class(PPr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function PPrUnitDecorator.GetObject();
begin
    return object_;
end;

function PPrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildSectPr) then
        {self.}XmlChildSectPr := new SectPrUnitDecorator(object_.XmlChildSectPr);
    if not ifnil(object_.XmlChildTabs) then
        {self.}XmlChildTabs := new TabsUnitDecorator(object_.XmlChildTabs);
    if not ifnil(object_.XmlChildBidi) then
        {self.}Bidi.Copy(object_.XmlChildBidi);
    if not ifnil(object_.XmlChildWidowControl) then
        {self.}WidowControl.Copy(object_.XmlChildWidowControl);
    if not ifnil(object_.XmlChildSnapToGrid) then
        {self.}SnapToGrid.Copy(object_.XmlChildSnapToGrid);
    if not ifnil(object_.XmlChildPStyle) then
        {self.}XmlChildPStyle := new PureWValUnitDecorator(object_.XmlChildPStyle);
    if not ifnil(object_.XmlChildNumPr) then
        {self.}XmlChildNumPr := new NumPrUnitDecorator(object_.XmlChildNumPr);
    if not ifnil(object_.XmlChildJc) then
        {self.}XmlChildJc := new PureWValUnitDecorator(object_.XmlChildJc);
    if not ifnil(object_.XmlChildInd) then
        {self.}XmlChildInd := new IndUnitDecorator(object_.XmlChildInd);
    if not ifnil(object_.XmlChildKeepNext) then
        {self.}KeepNext.Copy(object_.XmlChildKeepNext);
    if not ifnil(object_.XmlChildKeepLines) then
        {self.}KeepLines.Copy(object_.XmlChildKeepLines);
    if not ifnil(object_.XmlChildMirrorIndents) then
        {self.}MirrorIndents.Copy(object_.XmlChildMirrorIndents);
    if not ifnil(object_.XmlChildKinsoku) then
        {self.}XmlChildKinsoku := new PureWValUnitDecorator(object_.XmlChildKinsoku);
    if not ifnil(object_.XmlChildPageBreakBefore) then
        {self.}PageBreakBefore.Copy(object_.XmlChildPageBreakBefore);
    if not ifnil(object_.XmlChildSuppressAutoHyphens) then
        {self.}SuppressAutoHyphens.Copy(object_.XmlChildSuppressAutoHyphens);
    if not ifnil(object_.XmlChildSuppressLineNumbers) then
        {self.}SuppressLineNumbers.Copy(object_.XmlChildSuppressLineNumbers);
    if not ifnil(object_.XmlChildSuppressOverlap) then
        {self.}SuppressOverlap.Copy(object_.XmlChildSuppressOverlap);
    if not ifnil(object_.XmlChildOverflowPunct) then
        {self.}XmlChildOverflowPunct := new PureWValUnitDecorator(object_.XmlChildOverflowPunct);
    if not ifnil(object_.XmlChildAdjustRightInd) then
        {self.}XmlChildAdjustRightInd := new PureWValUnitDecorator(object_.XmlChildAdjustRightInd);
    if not ifnil(object_.XmlChildSpacing) then
        {self.}XmlChildSpacing := new SpacingUnitDecorator(object_.XmlChildSpacing);
    if not ifnil(object_.XmlChildOutlineLvl) then
        {self.}XmlChildOutlineLvl := new PureWValUnitDecorator(object_.XmlChildOutlineLvl);
    if not ifnil(object_.XmlChildAutoSpaceDE) then
        {self.}XmlChildAutoSpaceDE := new PureWValUnitDecorator(object_.XmlChildAutoSpaceDE);
    if not ifnil(object_.XmlChildAutoSpaceDN) then
        {self.}XmlChildAutoSpaceDN := new PureWValUnitDecorator(object_.XmlChildAutoSpaceDN);
    if not ifnil(object_.XmlChildRPr) then
        {self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
    if not ifnil(object_.XmlChildPBdr) then
        {self.}XmlChildPBdr := new PBdrUnitDecorator(object_.XmlChildPBdr);
    if not ifnil(object_.XmlChildContextualSpacing) then
        {self.}ContextualSpacing.Copy(object_.XmlChildContextualSpacing);
    if not ifnil(object_.XmlChildShd) then
        {self.}XmlChildShd := new ShdUnitDecorator(object_.XmlChildShd);
    if not ifnil(object_.XmlChildWordWrap) then
        {self.}XmlChildWordWrap := new PureWValUnitDecorator(object_.XmlChildWordWrap);
    if not ifnil(object_.XmlChildDivId) then
        {self.}XmlChildDivId := new PureWValUnitDecorator(object_.XmlChildDivId);
    if not ifnil(object_.XmlChildCnfStyle) then
        {self.}XmlChildCnfStyle := new PureWValUnitDecorator(object_.XmlChildCnfStyle);
    if not ifnil(object_.XmlChildFramePr) then
        {self.}XmlChildFramePr := new FramePrUnitDecorator(object_.XmlChildFramePr);
    if not ifnil(object_.XmlChildTextboxTightWrap) then
        {self.}XmlChildTextboxTightWrap := new PureWValUnitDecorator(object_.XmlChildTextboxTightWrap);
    if not ifnil(object_.XmlChildTopLinePunct) then
        {self.}XmlChildTopLinePunct := new PureWValUnitDecorator(object_.XmlChildTopLinePunct);
    if not ifnil(object_.XmlChildTextAlignment) then
        {self.}XmlChildTextAlignment := new PureWValUnitDecorator(object_.XmlChildTextAlignment);
    if not ifnil(object_.XmlChildTextDirection) then
        {self.}XmlChildTextDirection := new PureWValUnitDecorator(object_.XmlChildTextDirection);
    if not ifnil(object_.XmlChildCollapsed) then
        {self.}XmlChildCollapsed := new PureWValUnitDecorator(object_.XmlChildCollapsed);
    tslassigning := tslassigning_backup;
end;

function PBdrUnitDecorator.Create(_obj: PBdr);
begin
    class(PBdr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function PBdrUnitDecorator.GetObject();
begin
    return object_;
end;

function PBdrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildTop) then
        {self.}XmlChildTop := new PBorderUnitDecorator(object_.XmlChildTop);
    if not ifnil(object_.XmlChildLeft) then
        {self.}XmlChildLeft := new PBorderUnitDecorator(object_.XmlChildLeft);
    if not ifnil(object_.XmlChildRight) then
        {self.}XmlChildRight := new PBorderUnitDecorator(object_.XmlChildRight);
    if not ifnil(object_.XmlChildBottom) then
        {self.}XmlChildBottom := new PBorderUnitDecorator(object_.XmlChildBottom);
    if not ifnil(object_.XmlChildBetween) then
        {self.}XmlChildBetween := new PBorderUnitDecorator(object_.XmlChildBetween);
    tslassigning := tslassigning_backup;
end;

function FramePrUnitDecorator.Create(_obj: FramePr);
begin
    class(FramePr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function FramePrUnitDecorator.GetObject();
begin
    return object_;
end;

function FramePrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrAnchorLock) then
        {self.}AnchorLock := object_.XmlAttrAnchorLock.Value;
    if not ifnil(object_.XmlAttrDropCap) then
        {self.}DropCap := object_.XmlAttrDropCap.Value;
    if not ifnil(object_.XmlAttrVAnchor) then
        {self.}VAnchor := object_.XmlAttrVAnchor.Value;
    if not ifnil(object_.XmlAttrHAnchor) then
        {self.}HAnchor := object_.XmlAttrHAnchor.Value;
    if not ifnil(object_.XmlAttrHRule) then
        {self.}HRule := object_.XmlAttrHRule.Value;
    if not ifnil(object_.XmlAttrHSpace) then
        {self.}HSpace := object_.XmlAttrHSpace.Value;
    if not ifnil(object_.XmlAttrVSpace) then
        {self.}VSpace := object_.XmlAttrVSpace.Value;
    if not ifnil(object_.XmlAttrLines) then
        {self.}Lines := object_.XmlAttrLines.Value;
    if not ifnil(object_.XmlAttrWrap) then
        {self.}Wrap := object_.XmlAttrWrap.Value;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    if not ifnil(object_.XmlAttrW) then
        {self.}W := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrW.Value);
    if not ifnil(object_.XmlAttrH) then
        {self.}H := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrH.Value);
    if not ifnil(object_.XmlAttrX) then
        {self.}X := object_.XmlAttrX.Value;
    if not ifnil(object_.XmlAttrY) then
        {self.}Y := object_.XmlAttrY.Value;
    if not ifnil(object_.XmlAttrXAlign) then
        {self.}XAlign := object_.XmlAttrXAlign.Value;
    if not ifnil(object_.XmlAttrYAlign) then
        {self.}YAlign := object_.XmlAttrYAlign.Value;
    tslassigning := tslassigning_backup;
end;

function PBorderUnitDecorator.Create(_obj: PBorder);
begin
    class(PBorder).Create();
    object_ := _obj;
    {self.}Convert();
end;

function PBorderUnitDecorator.GetObject();
begin
    return object_;
end;

function PBorderUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    if not ifnil(object_.XmlAttrColor) then
        {self.}Color := object_.XmlAttrColor.Value;
    if not ifnil(object_.XmlAttrSpace) then
        {self.}Space := object_.XmlAttrSpace.Value;
    if not ifnil(object_.XmlAttrFrame) then
        {self.}Frame := object_.XmlAttrFrame.Value;
    if not ifnil(object_.XmlAttrShadow) then
        {self.}Shadow := object_.XmlAttrShadow.Value;
    if not ifnil(object_.XmlAttrThemeColor) then
        {self.}ThemeColor := object_.XmlAttrThemeColor.Value;
    if not ifnil(object_.XmlAttrThemeShade) then
        {self.}ThemeShade := object_.XmlAttrThemeShade.Value;
    if not ifnil(object_.XmlAttrThemeTint) then
        {self.}ThemeTint := object_.XmlAttrThemeTint.Value;
    if not ifnil(object_.XmlAttrSz) then
        {self.}Sz := TSSafeUnitConverter.HalfPointToPoints(object_.XmlAttrSz.Value);
    tslassigning := tslassigning_backup;
end;

function TabsUnitDecorator.Create(_obj: Tabs);
begin
    class(Tabs).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TabsUnitDecorator.GetObject();
begin
    return object_;
end;

function TabsUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    elems := object_.Tabs();
    for _,elem in elems do
        {self.}AppendChild(new TabUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function TabUnitDecorator.Create(_obj: Tab);
begin
    class(Tab).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TabUnitDecorator.GetObject();
begin
    return object_;
end;

function TabUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    if not ifnil(object_.XmlAttrLeader) then
        {self.}Leader := object_.XmlAttrLeader.Value;
    if not ifnil(object_.XmlAttrPos) then
        {self.}Pos := object_.XmlAttrPos.Value;
    tslassigning := tslassigning_backup;
end;

function NumPrUnitDecorator.Create(_obj: NumPr);
begin
    class(NumPr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function NumPrUnitDecorator.GetObject();
begin
    return object_;
end;

function NumPrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildIlvl) then
        {self.}XmlChildIlvl := new PureWValUnitDecorator(object_.XmlChildIlvl);
    if not ifnil(object_.XmlChildNumId) then
        {self.}XmlChildNumId := new PureWValUnitDecorator(object_.XmlChildNumId);
    tslassigning := tslassigning_backup;
end;

function IndUnitDecorator.Create(_obj: Ind);
begin
    class(Ind).Create();
    object_ := _obj;
    {self.}Convert();
end;

function IndUnitDecorator.GetObject();
begin
    return object_;
end;

function IndUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrFirstLineChars) then
        {self.}FirstLineChars := TSSafeUnitConverter.PercentToNumber(object_.XmlAttrFirstLineChars.Value);
    if not ifnil(object_.XmlAttrFirstLine) then
        {self.}FirstLine := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrFirstLine.Value);
    if not ifnil(object_.XmlAttrRightChars) then
        {self.}RightChars := TSSafeUnitConverter.PercentToNumber(object_.XmlAttrRightChars.Value);
    if not ifnil(object_.XmlAttrRight) then
        {self.}Right := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrRight.Value);
    if not ifnil(object_.XmlAttrLeftChars) then
        {self.}LeftChars := TSSafeUnitConverter.PercentToNumber(object_.XmlAttrLeftChars.Value);
    if not ifnil(object_.XmlAttrLeft) then
        {self.}Left := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrLeft.Value);
    if not ifnil(object_.XmlAttrHanging) then
        {self.}Hanging := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrHanging.Value);
    if not ifnil(object_.XmlAttrHangingChars) then
        {self.}HangingChars := TSSafeUnitConverter.PercentToNumber(object_.XmlAttrHangingChars.Value);
    tslassigning := tslassigning_backup;
end;

function SpacingUnitDecorator.Create(_obj: Spacing);
begin
    class(Spacing).Create();
    object_ := _obj;
    {self.}Convert();
end;

function SpacingUnitDecorator.GetObject();
begin
    return object_;
end;

function SpacingUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrBefore) then
        {self.}Before := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrBefore.Value);
    if not ifnil(object_.XmlAttrBeforeLines) then
        {self.}BeforeLines := TSSafeUnitConverter.PercentToNumber(object_.XmlAttrBeforeLines.Value);
    if not ifnil(object_.XmlAttrBeforeAutospacing) then
        {self.}BeforeAutospacing := object_.XmlAttrBeforeAutospacing.Value;
    if not ifnil(object_.XmlAttrAfter) then
        {self.}After := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrAfter.Value);
    if not ifnil(object_.XmlAttrAfterLines) then
        {self.}AfterLines := TSSafeUnitConverter.PercentToNumber(object_.XmlAttrAfterLines.Value);
    if not ifnil(object_.XmlAttrAfterAutospacing) then
        {self.}AfterAutospacing := object_.XmlAttrAfterAutospacing.Value;
    if not ifnil(object_.XmlAttrLine) then
        {self.}Line := TSSafeUnitConverter.ToInt(object_.XmlAttrLine.Value);
    if not ifnil(object_.XmlAttrLineRule) then
        {self.}LineRule := object_.XmlAttrLineRule.Value;
    tslassigning := tslassigning_backup;
end;

function RPrUnitDecorator.Create(_obj: RPr);
begin
    class(RPr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function RPrUnitDecorator.GetObject();
begin
    return object_;
end;

function RPrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildNoProof) then
        {self.}XmlChildNoProof := new PureValUnitDecorator(object_.XmlChildNoProof);
    if not ifnil(object_.XmlChildOutline) then
        {self.}XmlChildOutline := new PureValUnitDecorator(object_.XmlChildOutline);
    if not ifnil(object_.XmlChildPosition) then
        {self.}XmlChildPosition := new PureValUnitDecorator(object_.XmlChildPosition);
    if not ifnil(object_.XmlChildWebHidden) then
        {self.}XmlChildWebHidden := new PureWValUnitDecorator(object_.XmlChildWebHidden);
    if not ifnil(object_.XmlChildRStyle) then
        {self.}XmlChildRStyle := new PureWValUnitDecorator(object_.XmlChildRStyle);
    if not ifnil(object_.XmlChildIns) then
        {self.}XmlChildIns := new InsUnitDecorator(object_.XmlChildIns);
    if not ifnil(object_.XmlChildRFonts) then
        {self.}XmlChildRFonts := new RFontsUnitDecorator(object_.XmlChildRFonts);
    if not ifnil(object_.XmlChildKern) then
        {self.}XmlChildKern := new PureWValUnitDecorator(object_.XmlChildKern);
    if not ifnil(object_.XmlChildI) then
        {self.}I.Copy(object_.XmlChildI);
    if not ifnil(object_.XmlChildICs) then
        {self.}ICs.Copy(object_.XmlChildICs);
    if not ifnil(object_.XmlChildB) then
        {self.}B.Copy(object_.XmlChildB);
    if not ifnil(object_.XmlChildBCs) then
        {self.}BCs.Copy(object_.XmlChildBCs);
    if not ifnil(object_.XmlChildBdr) then
        {self.}XmlChildBdr := new BdrUnitDecorator(object_.XmlChildBdr);
    if not ifnil(object_.XmlChildCaps) then
        {self.}XmlChildCaps := new PureWValUnitDecorator(object_.XmlChildCaps);
    if not ifnil(object_.XmlChildDel) then
        {self.}XmlChildDel := new DelUnitDecorator(object_.XmlChildDel);
    if not ifnil(object_.XmlChildStrike) then
        {self.}Strike.Copy(object_.XmlChildStrike);
    if not ifnil(object_.XmlChildDStrike) then
        {self.}XmlChildDStrike := new PureWValUnitDecorator(object_.XmlChildDStrike);
    if not ifnil(object_.XmlChildEffect) then
        {self.}XmlChildEffect := new PureWValUnitDecorator(object_.XmlChildEffect);
    if not ifnil(object_.XmlChildEm) then
        {self.}XmlChildEm := new PureWValUnitDecorator(object_.XmlChildEm);
    if not ifnil(object_.XmlChildEmboss) then
        {self.}XmlChildEmboss := new PureWValUnitDecorator(object_.XmlChildEmboss);
    if not ifnil(object_.XmlChildFitText) then
        {self.}XmlChildFitText := new FitTextUnitDecorator(object_.XmlChildFitText);
    if not ifnil(object_.XmlChildHighlight) then
        {self.}XmlChildHighlight := new HighlightUnitDecorator(object_.XmlChildHighlight);
    if not ifnil(object_.XmlChildColor) then
        {self.}XmlChildColor := new ColorUnitDecorator(object_.XmlChildColor);
    if not ifnil(object_.XmlChildEastAsianLayout) then
        {self.}XmlChildEastAsianLayout := new EastAsianLayoutUnitDecorator(object_.XmlChildEastAsianLayout);
    if not ifnil(object_.XmlChildCs) then
        {self.}Cs.Copy(object_.XmlChildCs);
    if not ifnil(object_.XmlChildSz) then
        {self.}XmlChildSz := new SzUnitDecorator(object_.XmlChildSz);
    if not ifnil(object_.XmlChildSzCs) then
        {self.}XmlChildSzCs := new SzCsUnitDecorator(object_.XmlChildSzCs);
    if not ifnil(object_.XmlChildU) then
        {self.}U.Copy(object_.XmlChildU);
    if not ifnil(object_.XmlChildLang) then
        {self.}XmlChildLang := new LangUnitDecorator(object_.XmlChildLang);
    if not ifnil(object_.XmlChildImprint) then
        {self.}XmlChildImprint := new PureWValUnitDecorator(object_.XmlChildImprint);
    if not ifnil(object_.XmlChildVertAlign) then
        {self.}XmlChildVertAlign := new PureWValUnitDecorator(object_.XmlChildVertAlign);
    if not ifnil(object_.XmlChildLigatures) then
        {self.}XmlChildLigatures := new PureWValUnitDecorator(object_.XmlChildLigatures);
    if not ifnil(object_.XmlChildRtl) then
        {self.}XmlChildRtl := new PureWValUnitDecorator(object_.XmlChildRtl);
    if not ifnil(object_.XmlChildOMath) then
        {self.}OMath.Copy(object_.XmlChildOMath);
    if not ifnil(object_.XmlChildShadow) then
        {self.}Shadow.Copy(object_.XmlChildShadow);
    if not ifnil(object_.XmlChildSpecVanish) then
        {self.}SpecVanish.Copy(object_.XmlChildSpecVanish);
    if not ifnil(object_.XmlChildVanish) then
        {self.}Vanish.Copy(object_.XmlChildVanish);
    if not ifnil(object_.XmlChildShd) then
        {self.}XmlChildShd := new ShdUnitDecorator(object_.XmlChildShd);
    if not ifnil(object_.XmlChildSmallCaps) then
        {self.}XmlChildSmallCaps := new PureWValUnitDecorator(object_.XmlChildSmallCaps);
    if not ifnil(object_.XmlChildW) then
        {self.}XmlChildW := new PureWValUnitDecorator(object_.XmlChildW);
    tslassigning := tslassigning_backup;
end;

function ShdUnitDecorator.Create(_obj: Shd);
begin
    class(Shd).Create();
    object_ := _obj;
    {self.}Convert();
end;

function ShdUnitDecorator.GetObject();
begin
    return object_;
end;

function ShdUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    if not ifnil(object_.XmlAttrColor) then
        {self.}Color := object_.XmlAttrColor.Value;
    if not ifnil(object_.XmlAttrFill) then
        {self.}Fill := object_.XmlAttrFill.Value;
    if not ifnil(object_.XmlAttrThemeColor) then
        {self.}ThemeColor := object_.XmlAttrThemeColor.Value;
    if not ifnil(object_.XmlAttrThemeFill) then
        {self.}ThemeFill := object_.XmlAttrThemeFill.Value;
    if not ifnil(object_.XmlAttrThemeFillTint) then
        {self.}ThemeFillTint := object_.XmlAttrThemeFillTint.Value;
    if not ifnil(object_.XmlAttrThemeFillShade) then
        {self.}ThemeFillShade := object_.XmlAttrThemeFillShade.Value;
    if not ifnil(object_.XmlAttrThemeShade) then
        {self.}ThemeShade := object_.XmlAttrThemeShade.Value;
    if not ifnil(object_.XmlAttrThemeTint) then
        {self.}ThemeTint := object_.XmlAttrThemeTint.Value;
    tslassigning := tslassigning_backup;
end;

function HighlightUnitDecorator.Create(_obj: Highlight);
begin
    class(Highlight).Create();
    object_ := _obj;
    {self.}Convert();
end;

function HighlightUnitDecorator.GetObject();
begin
    return object_;
end;

function HighlightUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    tslassigning := tslassigning_backup;
end;

function FitTextUnitDecorator.Create(_obj: FitText);
begin
    class(FitText).Create();
    object_ := _obj;
    {self.}Convert();
end;

function FitTextUnitDecorator.GetObject();
begin
    return object_;
end;

function FitTextUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrId) then
        {self.}Id := object_.XmlAttrId.Value;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    tslassigning := tslassigning_backup;
end;

function EastAsianLayoutUnitDecorator.Create(_obj: EastAsianLayout);
begin
    class(EastAsianLayout).Create();
    object_ := _obj;
    {self.}Convert();
end;

function EastAsianLayoutUnitDecorator.GetObject();
begin
    return object_;
end;

function EastAsianLayoutUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrCombine) then
        {self.}Combine := object_.XmlAttrCombine.Value;
    if not ifnil(object_.XmlAttrCombineBrackets) then
        {self.}CombineBrackets := object_.XmlAttrCombineBrackets.Value;
    if not ifnil(object_.XmlAttrId) then
        {self.}Id := object_.XmlAttrId.Value;
    if not ifnil(object_.XmlAttrVert) then
        {self.}Vert := object_.XmlAttrVert.Value;
    if not ifnil(object_.XmlAttrVertCompress) then
        {self.}VertCompress := object_.XmlAttrVertCompress.Value;
    tslassigning := tslassigning_backup;
end;

function DelUnitDecorator.Create(_obj: Del);
begin
    class(Del).Create();
    object_ := _obj;
    {self.}Convert();
end;

function DelUnitDecorator.GetObject();
begin
    return object_;
end;

function DelUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrAuthor) then
        {self.}Author := object_.XmlAttrAuthor.Value;
    if not ifnil(object_.XmlAttrDate) then
        {self.}Date := object_.XmlAttrDate.Value;
    if not ifnil(object_.XmlAttrId) then
        {self.}Id := object_.XmlAttrId.Value;
    if not ifnil(object_.XmlAttrColor) then
        {self.}Color := object_.XmlAttrColor.Value;
    if not ifnil(object_.XmlAttrThemeColor) then
        {self.}ThemeColor := object_.XmlAttrThemeColor.Value;
    if not ifnil(object_.XmlAttrThemeShade) then
        {self.}ThemeShade := object_.XmlAttrThemeShade.Value;
    if not ifnil(object_.XmlAttrThemeTint) then
        {self.}ThemeTint := object_.XmlAttrThemeTint.Value;
    if not ifnil(object_.XmlAttrFrame) then
        {self.}Frame := object_.XmlAttrFrame.Value;
    if not ifnil(object_.XmlAttrShadow) then
        {self.}Shadow := object_.XmlAttrShadow.Value;
    tslassigning := tslassigning_backup;
end;

function BdrUnitDecorator.Create(_obj: Bdr);
begin
    class(Bdr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function BdrUnitDecorator.GetObject();
begin
    return object_;
end;

function BdrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    if not ifnil(object_.XmlAttrSz) then
        {self.}Sz := object_.XmlAttrSz.Value;
    if not ifnil(object_.XmlAttrSpace) then
        {self.}Space := object_.XmlAttrSpace.Value;
    if not ifnil(object_.XmlAttrColor) then
        {self.}Color := object_.XmlAttrColor.Value;
    if not ifnil(object_.XmlAttrThemeColor) then
        {self.}ThemeColor := object_.XmlAttrThemeColor.Value;
    if not ifnil(object_.XmlAttrThemeShade) then
        {self.}ThemeShade := object_.XmlAttrThemeShade.Value;
    if not ifnil(object_.XmlAttrThemeTint) then
        {self.}ThemeTint := object_.XmlAttrThemeTint.Value;
    if not ifnil(object_.XmlAttrFrame) then
        {self.}Frame := object_.XmlAttrFrame.Value;
    if not ifnil(object_.XmlAttrShadow) then
        {self.}Shadow := object_.XmlAttrShadow.Value;
    tslassigning := tslassigning_backup;
end;

function RFontsUnitDecorator.Create(_obj: RFonts);
begin
    class(RFonts).Create();
    object_ := _obj;
    {self.}Convert();
end;

function RFontsUnitDecorator.GetObject();
begin
    return object_;
end;

function RFontsUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrHint) then
        {self.}Hint := object_.XmlAttrHint.Value;
    if not ifnil(object_.XmlAttrAscii) then
        {self.}Ascii := object_.XmlAttrAscii.Value;
    if not ifnil(object_.XmlAttrAsciiTheme) then
        {self.}AsciiTheme := object_.XmlAttrAsciiTheme.Value;
    if not ifnil(object_.XmlAttrEastAsia) then
        {self.}EastAsia := object_.XmlAttrEastAsia.Value;
    if not ifnil(object_.XmlAttrEastAsiaTheme) then
        {self.}EastAsiaTheme := object_.XmlAttrEastAsiaTheme.Value;
    if not ifnil(object_.XmlAttrHAnsi) then
        {self.}HAnsi := object_.XmlAttrHAnsi.Value;
    if not ifnil(object_.XmlAttrHAnsiTheme) then
        {self.}HAnsiTheme := object_.XmlAttrHAnsiTheme.Value;
    if not ifnil(object_.XmlAttrCs) then
        {self.}Cs := object_.XmlAttrCs.Value;
    if not ifnil(object_.XmlAttrCsTheme) then
        {self.}CsTheme := object_.XmlAttrCsTheme.Value;
    tslassigning := tslassigning_backup;
end;

function SzCsUnitDecorator.Create(_obj: SzCs);
begin
    class(SzCs).Create();
    object_ := _obj;
    {self.}Convert();
end;

function SzCsUnitDecorator.GetObject();
begin
    return object_;
end;

function SzCsUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := TSSafeUnitConverter.HalfPointToPoints(object_.XmlAttrVal.Value);
    tslassigning := tslassigning_backup;
end;

function SzUnitDecorator.Create(_obj: Sz);
begin
    class(Sz).Create();
    object_ := _obj;
    {self.}Convert();
end;

function SzUnitDecorator.GetObject();
begin
    return object_;
end;

function SzUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := TSSafeUnitConverter.HalfPointToPoints(object_.XmlAttrVal.Value);
    tslassigning := tslassigning_backup;
end;

function PureValUnitDecorator.Create(_obj: PureVal);
begin
    class(PureVal).Create();
    object_ := _obj;
    {self.}Convert();
end;

function PureValUnitDecorator.GetObject();
begin
    return object_;
end;

function PureValUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    tslassigning := tslassigning_backup;
end;

function PureWValUnitDecorator.Create(_obj: PureWVal);
begin
    class(PureWVal).Create();
    object_ := _obj;
    {self.}Convert();
end;

function PureWValUnitDecorator.GetObject();
begin
    return object_;
end;

function PureWValUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    tslassigning := tslassigning_backup;
end;

function ColorUnitDecorator.Create(_obj: Color);
begin
    class(Color).Create();
    object_ := _obj;
    {self.}Convert();
end;

function ColorUnitDecorator.GetObject();
begin
    return object_;
end;

function ColorUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    if not ifnil(object_.XmlAttrThemeColor) then
        {self.}ThemeColor := object_.XmlAttrThemeColor.Value;
    tslassigning := tslassigning_backup;
end;

function LangUnitDecorator.Create(_obj: Lang);
begin
    class(Lang).Create();
    object_ := _obj;
    {self.}Convert();
end;

function LangUnitDecorator.GetObject();
begin
    return object_;
end;

function LangUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    if not ifnil(object_.XmlAttrEastAsia) then
        {self.}EastAsia := object_.XmlAttrEastAsia.Value;
    if not ifnil(object_.XmlAttrBidi) then
        {self.}Bidi := object_.XmlAttrBidi.Value;
    tslassigning := tslassigning_backup;
end;

function RUnitDecorator.Create(_obj: R);
begin
    class(R).Create();
    object_ := _obj;
    {self.}Convert();
end;

function RUnitDecorator.GetObject();
begin
    return object_;
end;

function RUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrRsidRPr) then
        {self.}RsidRPr := object_.XmlAttrRsidRPr.Value;
    if not ifnil(object_.XmlAttrAnchor) then
        {self.}Anchor := object_.XmlAttrAnchor.Value;
    if not ifnil(object_.XmlAttrHistory) then
        {self.}History := object_.XmlAttrHistory.Value;
    elems := object_.Rs();
    for _,elem in elems do
        {self.}AppendChild(new RUnitDecorator(elem));
    if not ifnil(object_.XmlChildRPr) then
        {self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
    if not ifnil(object_.XmlChildBr) then
        {self.}XmlChildBr := new BrUnitDecorator(object_.XmlChildBr);
    if not ifnil(object_.XmlChildFldChar) then
        {self.}XmlChildFldChar := new FldCharUnitDecorator(object_.XmlChildFldChar);
    if not ifnil(object_.XmlChildInstrText) then
        {self.}XmlChildInstrText := new InstrTextUnitDecorator(object_.XmlChildInstrText);
    if not ifnil(object_.XmlChildSeparator) then
        {self.}Separator.Copy(object_.XmlChildSeparator);
    if not ifnil(object_.XmlChildContinuationSeparator) then
        {self.}ContinuationSeparator.Copy(object_.XmlChildContinuationSeparator);
    if not ifnil(object_.XmlChildLastRenderedPageBreak) then
        {self.}LastRenderedPageBreak.Copy(object_.XmlChildLastRenderedPageBreak);
    if not ifnil(object_.XmlChildAlternateContent) then
        {self.}XmlChildAlternateContent := new AlternateContentUnitDecorator(object_.XmlChildAlternateContent);
    if not ifnil(object_.XmlChildDrawing) then
        {self.}XmlChildDrawing := new DrawingUnitDecorator(object_.XmlChildDrawing);
    if not ifnil(object_.XmlChildPict) then
        {self.}XmlChildPict := new PictUnitDecorator(object_.XmlChildPict);
    if not ifnil(object_.XmlChildT) then
        {self.}XmlChildT := new TUnitDecorator(object_.XmlChildT);
    if not ifnil(object_.XmlChildObject) then
        {self.}XmlChildObject := new ObjectUnitDecorator(object_.XmlChildObject);
    if not ifnil(object_.XmlChildFootnoteReference) then
        {self.}XmlChildFootnoteReference := new FootnoteReferenceUnitDecorator(object_.XmlChildFootnoteReference);
    if not ifnil(object_.XmlChildFootnoteRef) then
        {self.}FootnoteRef.Copy(object_.XmlChildFootnoteRef);
    if not ifnil(object_.XmlChildCommentReference) then
        {self.}XmlChildCommentReference := new CommentReferenceUnitDecorator(object_.XmlChildCommentReference);
    tslassigning := tslassigning_backup;
end;

function CommentReferenceUnitDecorator.Create(_obj: CommentReference);
begin
    class(CommentReference).Create();
    object_ := _obj;
    {self.}Convert();
end;

function CommentReferenceUnitDecorator.GetObject();
begin
    return object_;
end;

function CommentReferenceUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrId) then
        {self.}Id := object_.XmlAttrId.Value;
    tslassigning := tslassigning_backup;
end;

function ObjectUnitDecorator.Create(_obj: Object);
begin
    class(Object).Create();
    object_ := _obj;
    {self.}Convert();
end;

function ObjectUnitDecorator.GetObject();
begin
    return object_;
end;

function ObjectUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrDxaOrig) then
        {self.}DxaOrig := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrDxaOrig.Value);
    if not ifnil(object_.XmlAttrDyaOrig) then
        {self.}DyaOrig := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrDyaOrig.Value);
    if not ifnil(object_.XmlAttrAnchorId) then
        {self.}AnchorId := object_.XmlAttrAnchorId.Value;
    if not ifnil(object_.XmlChildShapetype) then
        {self.}XmlChildShapetype := new ShapetypeUnitDecorator(object_.XmlChildShapetype);
    if not ifnil(object_.XmlChildShape) then
        {self.}XmlChildShape := new ShapeUnitDecorator(object_.XmlChildShape);
    if not ifnil(object_.XmlChildOLEObject) then
        {self.}XmlChildOLEObject := new OLEObjectUnitDecorator(object_.XmlChildOLEObject);
    tslassigning := tslassigning_backup;
end;

function FootnoteReferenceUnitDecorator.Create(_obj: FootnoteReference);
begin
    class(FootnoteReference).Create();
    object_ := _obj;
    {self.}Convert();
end;

function FootnoteReferenceUnitDecorator.GetObject();
begin
    return object_;
end;

function FootnoteReferenceUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrId) then
        {self.}Id := object_.XmlAttrId.Value;
    tslassigning := tslassigning_backup;
end;

function FldCharUnitDecorator.Create(_obj: FldChar);
begin
    class(FldChar).Create();
    object_ := _obj;
    {self.}Convert();
end;

function FldCharUnitDecorator.GetObject();
begin
    return object_;
end;

function FldCharUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrFldCharType) then
        {self.}FldCharType := object_.XmlAttrFldCharType.Value;
    if not ifnil(object_.XmlAttrFldLock) then
        {self.}FldLock := object_.XmlAttrFldLock.Value;
    if not ifnil(object_.XmlAttrDirty) then
        {self.}Dirty := object_.XmlAttrDirty.Value;
    tslassigning := tslassigning_backup;
end;

function InstrTextUnitDecorator.Create(_obj: InstrText);
begin
    class(InstrText).Create();
    object_ := _obj;
    {self.}Convert();
end;

function InstrTextUnitDecorator.GetObject();
begin
    return object_;
end;

function InstrTextUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrSpace) then
        {self.}Space := object_.XmlAttrSpace.Value;
    tslassigning := tslassigning_backup;
end;

function BrUnitDecorator.Create(_obj: Br);
begin
    class(Br).Create();
    object_ := _obj;
    {self.}Convert();
end;

function BrUnitDecorator.GetObject();
begin
    return object_;
end;

function BrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrType) then
        {self.}Type := object_.XmlAttrType.Value;
    tslassigning := tslassigning_backup;
end;

function TxbxContentUnitDecorator.Create(_obj: TxbxContent);
begin
    class(TxbxContent).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TxbxContentUnitDecorator.GetObject();
begin
    return object_;
end;

function TxbxContentUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    elems := object_.Ps();
    for _,elem in elems do
        {self.}AppendChild(new PUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function DrawingUnitDecorator.Create(_obj: Drawing);
begin
    class(Drawing).Create();
    object_ := _obj;
    {self.}Convert();
end;

function DrawingUnitDecorator.GetObject();
begin
    return object_;
end;

function DrawingUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChild_Inline) then
        {self.}XmlChild_Inline := new _InlineUnitDecorator(object_.XmlChild_Inline);
    if not ifnil(object_.XmlChildAnchor) then
        {self.}XmlChildAnchor := new AnchorUnitDecorator(object_.XmlChildAnchor);
    tslassigning := tslassigning_backup;
end;

function TUnitDecorator.Create(_obj: T);
begin
    class(T).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TUnitDecorator.GetObject();
begin
    return object_;
end;

function TUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrSpace) then
        {self.}Space := object_.XmlAttrSpace.Value;
    tslassigning := tslassigning_backup;
end;

function TblUnitDecorator.Create(_obj: Tbl);
begin
    class(Tbl).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TblUnitDecorator.GetObject();
begin
    return object_;
end;

function TblUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildTblPr) then
        {self.}XmlChildTblPr := new TblPrUnitDecorator(object_.XmlChildTblPr);
    if not ifnil(object_.XmlChildTblGrid) then
        {self.}XmlChildTblGrid := new TblGridUnitDecorator(object_.XmlChildTblGrid);
    elems := object_.Trs();
    for _,elem in elems do
        {self.}AppendChild(new TrUnitDecorator(elem));
    elems := object_.Sdts();
    for _,elem in elems do
        {self.}AppendChild(new SdtUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function TblPrUnitDecorator.Create(_obj: TblPr);
begin
    class(TblPr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TblPrUnitDecorator.GetObject();
begin
    return object_;
end;

function TblPrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildJc) then
        {self.}XmlChildJc := new PureWValUnitDecorator(object_.XmlChildJc);
    if not ifnil(object_.XmlChildShd) then
        {self.}XmlChildShd := new ShdUnitDecorator(object_.XmlChildShd);
    if not ifnil(object_.XmlChildTblStyle) then
        {self.}XmlChildTblStyle := new PureWValUnitDecorator(object_.XmlChildTblStyle);
    if not ifnil(object_.XmlChildTblW) then
        {self.}XmlChildTblW := new TblWUnitDecorator(object_.XmlChildTblW);
    if not ifnil(object_.XmlChildTblInd) then
        {self.}XmlChildTblInd := new TblWUnitDecorator(object_.XmlChildTblInd);
    if not ifnil(object_.XmlChildTblLayout) then
        {self.}XmlChildTblLayout := new TblLayoutUnitDecorator(object_.XmlChildTblLayout);
    if not ifnil(object_.XmlChildTblLook) then
        {self.}XmlChildTblLook := new TblLookUnitDecorator(object_.XmlChildTblLook);
    if not ifnil(object_.XmlChildTblBorders) then
        {self.}XmlChildTblBorders := new TblBordersUnitDecorator(object_.XmlChildTblBorders);
    if not ifnil(object_.XmlChildTblCellMar) then
        {self.}XmlChildTblCellMar := new TblCellMarUnitDecorator(object_.XmlChildTblCellMar);
    if not ifnil(object_.XmlChildTblCellSpacing) then
        {self.}XmlChildTblCellSpacing := new TblCellSpacingUnitDecorator(object_.XmlChildTblCellSpacing);
    if not ifnil(object_.XmlChildTblCaption) then
        {self.}XmlChildTblCaption := new PureWValUnitDecorator(object_.XmlChildTblCaption);
    if not ifnil(object_.XmlChildTblDescription) then
        {self.}XmlChildTblDescription := new PureWValUnitDecorator(object_.XmlChildTblDescription);
    if not ifnil(object_.XmlChildTblStyleRowBandSize) then
        {self.}XmlChildTblStyleRowBandSize := new PureWValUnitDecorator(object_.XmlChildTblStyleRowBandSize);
    if not ifnil(object_.XmlChildTblStyleColBandSize) then
        {self.}XmlChildTblStyleColBandSize := new PureWValUnitDecorator(object_.XmlChildTblStyleColBandSize);
    tslassigning := tslassigning_backup;
end;

function TblCellSpacingUnitDecorator.Create(_obj: TblCellSpacing);
begin
    class(TblCellSpacing).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TblCellSpacingUnitDecorator.GetObject();
begin
    return object_;
end;

function TblCellSpacingUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrW) then
        {self.}W := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrW.Value);
    if not ifnil(object_.XmlAttrType) then
        {self.}Type := object_.XmlAttrType.Value;
    tslassigning := tslassigning_backup;
end;

function TblWUnitDecorator.Create(_obj: TblW);
begin
    class(TblW).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TblWUnitDecorator.GetObject();
begin
    return object_;
end;

function TblWUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrW) then
        {self.}W := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrW.Value);
    if not ifnil(object_.XmlAttrType) then
        {self.}Type := object_.XmlAttrType.Value;
    tslassigning := tslassigning_backup;
end;

function TblLayoutUnitDecorator.Create(_obj: TblLayout);
begin
    class(TblLayout).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TblLayoutUnitDecorator.GetObject();
begin
    return object_;
end;

function TblLayoutUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrType) then
        {self.}Type := object_.XmlAttrType.Value;
    tslassigning := tslassigning_backup;
end;

function TblLookUnitDecorator.Create(_obj: TblLook);
begin
    class(TblLook).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TblLookUnitDecorator.GetObject();
begin
    return object_;
end;

function TblLookUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    if not ifnil(object_.XmlAttrFirstRow) then
        {self.}FirstRow := object_.XmlAttrFirstRow.Value;
    if not ifnil(object_.XmlAttrLastRow) then
        {self.}LastRow := object_.XmlAttrLastRow.Value;
    if not ifnil(object_.XmlAttrFirstColumn) then
        {self.}FirstColumn := object_.XmlAttrFirstColumn.Value;
    if not ifnil(object_.XmlAttrLastColumn) then
        {self.}LastColumn := object_.XmlAttrLastColumn.Value;
    if not ifnil(object_.XmlAttrNoHBand) then
        {self.}NoHBand := object_.XmlAttrNoHBand.Value;
    if not ifnil(object_.XmlAttrNoVBand) then
        {self.}NoVBand := object_.XmlAttrNoVBand.Value;
    tslassigning := tslassigning_backup;
end;

function TblBordersUnitDecorator.Create(_obj: TblBorders);
begin
    class(TblBorders).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TblBordersUnitDecorator.GetObject();
begin
    return object_;
end;

function TblBordersUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildTop) then
        {self.}XmlChildTop := new TblBorderUnitDecorator(object_.XmlChildTop);
    if not ifnil(object_.XmlChildLeft) then
        {self.}XmlChildLeft := new TblBorderUnitDecorator(object_.XmlChildLeft);
    if not ifnil(object_.XmlChildBottom) then
        {self.}XmlChildBottom := new TblBorderUnitDecorator(object_.XmlChildBottom);
    if not ifnil(object_.XmlChildRight) then
        {self.}XmlChildRight := new TblBorderUnitDecorator(object_.XmlChildRight);
    if not ifnil(object_.XmlChildInsideH) then
        {self.}XmlChildInsideH := new TblBorderUnitDecorator(object_.XmlChildInsideH);
    if not ifnil(object_.XmlChildInsideV) then
        {self.}XmlChildInsideV := new TblBorderUnitDecorator(object_.XmlChildInsideV);
    tslassigning := tslassigning_backup;
end;

function TblBorderUnitDecorator.Create(_obj: TblBorder);
begin
    class(TblBorder).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TblBorderUnitDecorator.GetObject();
begin
    return object_;
end;

function TblBorderUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    if not ifnil(object_.XmlAttrColor) then
        {self.}Color := object_.XmlAttrColor.Value;
    if not ifnil(object_.XmlAttrSpace) then
        {self.}Space := object_.XmlAttrSpace.Value;
    if not ifnil(object_.XmlAttrThemeColor) then
        {self.}ThemeColor := object_.XmlAttrThemeColor.Value;
    if not ifnil(object_.XmlAttrThemeTint) then
        {self.}ThemeTint := object_.XmlAttrThemeTint.Value;
    if not ifnil(object_.XmlAttrSz) then
        {self.}Sz := TSSafeUnitConverter.EighthPointToPoints(object_.XmlAttrSz.Value);
    tslassigning := tslassigning_backup;
end;

function TblGridUnitDecorator.Create(_obj: TblGrid);
begin
    class(TblGrid).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TblGridUnitDecorator.GetObject();
begin
    return object_;
end;

function TblGridUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    elems := object_.GridCols();
    for _,elem in elems do
        {self.}AppendChild(new GridColUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function GridColUnitDecorator.Create(_obj: GridCol);
begin
    class(GridCol).Create();
    object_ := _obj;
    {self.}Convert();
end;

function GridColUnitDecorator.GetObject();
begin
    return object_;
end;

function GridColUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrw) then
        {self.}w := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrw.Value);
    tslassigning := tslassigning_backup;
end;

function TrUnitDecorator.Create(_obj: Tr);
begin
    class(Tr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TrUnitDecorator.GetObject();
begin
    return object_;
end;

function TrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrRsidR) then
        {self.}RsidR := object_.XmlAttrRsidR.Value;
    if not ifnil(object_.XmlAttrParaId) then
        {self.}ParaId := object_.XmlAttrParaId.Value;
    if not ifnil(object_.XmlAttrTextId) then
        {self.}TextId := object_.XmlAttrTextId.Value;
    if not ifnil(object_.XmlAttrRsidTr) then
        {self.}RsidTr := object_.XmlAttrRsidTr.Value;
    if not ifnil(object_.XmlChildTrPr) then
        {self.}XmlChildTrPr := new TrPrUnitDecorator(object_.XmlChildTrPr);
    elems := object_.Sdts();
    for _,elem in elems do
        {self.}AppendChild(new SdtUnitDecorator(elem));
    elems := object_.Tcs();
    for _,elem in elems do
        {self.}AppendChild(new TcUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function TrPrUnitDecorator.Create(_obj: TrPr);
begin
    class(TrPr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TrPrUnitDecorator.GetObject();
begin
    return object_;
end;

function TrPrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildTrHeight) then
        {self.}XmlChildTrHeight := new TrHeightUnitDecorator(object_.XmlChildTrHeight);
    if not ifnil(object_.XmlChildTblHeader) then
        {self.}XmlChildTblHeader := new PureWValUnitDecorator(object_.XmlChildTblHeader);
    if not ifnil(object_.XmlChildJc) then
        {self.}XmlChildJc := new PureWValUnitDecorator(object_.XmlChildJc);
    if not ifnil(object_.XmlChildCantSplit) then
        {self.}CantSplit.Copy(object_.XmlChildCantSplit);
    if not ifnil(object_.XmlChildCnfStyle) then
        {self.}XmlChildCnfStyle := new CnfStyleUnitDecorator(object_.XmlChildCnfStyle);
    if not ifnil(object_.XmlChildIns) then
        {self.}XmlChildIns := new InsUnitDecorator(object_.XmlChildIns);
    if not ifnil(object_.XmlChildDel) then
        {self.}XmlChildDel := new DelUnitDecorator(object_.XmlChildDel);
    tslassigning := tslassigning_backup;
end;

function InsUnitDecorator.Create(_obj: Ins);
begin
    class(Ins).Create();
    object_ := _obj;
    {self.}Convert();
end;

function InsUnitDecorator.GetObject();
begin
    return object_;
end;

function InsUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrId) then
        {self.}Id := object_.XmlAttrId.Value;
    if not ifnil(object_.XmlAttrAuthor) then
        {self.}Author := object_.XmlAttrAuthor.Value;
    if not ifnil(object_.XmlAttrDate) then
        {self.}Date := object_.XmlAttrDate.Value;
    if not ifnil(object_.XmlAttrDateUtc) then
        {self.}DateUtc := object_.XmlAttrDateUtc.Value;
    elems := object_.Rs();
    for _,elem in elems do
        {self.}AppendChild(new RUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function CnfStyleUnitDecorator.Create(_obj: CnfStyle);
begin
    class(CnfStyle).Create();
    object_ := _obj;
    {self.}Convert();
end;

function CnfStyleUnitDecorator.GetObject();
begin
    return object_;
end;

function CnfStyleUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    if not ifnil(object_.XmlAttrFirstRow) then
        {self.}FirstRow := object_.XmlAttrFirstRow.Value;
    if not ifnil(object_.XmlAttrLastRow) then
        {self.}LastRow := object_.XmlAttrLastRow.Value;
    if not ifnil(object_.XmlAttrFirstColumn) then
        {self.}FirstColumn := object_.XmlAttrFirstColumn.Value;
    if not ifnil(object_.XmlAttrLastColumn) then
        {self.}LastColumn := object_.XmlAttrLastColumn.Value;
    if not ifnil(object_.XmlAttrOddVBand) then
        {self.}OddVBand := object_.XmlAttrOddVBand.Value;
    if not ifnil(object_.XmlAttrEvenVBand) then
        {self.}EvenVBand := object_.XmlAttrEvenVBand.Value;
    if not ifnil(object_.XmlAttrOddHBand) then
        {self.}OddHBand := object_.XmlAttrOddHBand.Value;
    if not ifnil(object_.XmlAttrEvenHBand) then
        {self.}EvenHBand := object_.XmlAttrEvenHBand.Value;
    if not ifnil(object_.XmlAttrFirstRowFirstColumn) then
        {self.}FirstRowFirstColumn := object_.XmlAttrFirstRowFirstColumn.Value;
    if not ifnil(object_.XmlAttrFirstRowLastColumn) then
        {self.}FirstRowLastColumn := object_.XmlAttrFirstRowLastColumn.Value;
    if not ifnil(object_.XmlAttrLastRowFirstColumn) then
        {self.}LastRowFirstColumn := object_.XmlAttrLastRowFirstColumn.Value;
    if not ifnil(object_.XmlAttrLastRowLastColumn) then
        {self.}LastRowLastColumn := object_.XmlAttrLastRowLastColumn.Value;
    tslassigning := tslassigning_backup;
end;

function TrHeightUnitDecorator.Create(_obj: TrHeight);
begin
    class(TrHeight).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TrHeightUnitDecorator.GetObject();
begin
    return object_;
end;

function TrHeightUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrHRule) then
        {self.}HRule := object_.XmlAttrHRule.Value;
    if not ifnil(object_.XmlAttrval) then
        {self.}val := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrval.Value);
    tslassigning := tslassigning_backup;
end;

function TcUnitDecorator.Create(_obj: Tc);
begin
    class(Tc).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TcUnitDecorator.GetObject();
begin
    return object_;
end;

function TcUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildTcPr) then
        {self.}XmlChildTcPr := new TcPrUnitDecorator(object_.XmlChildTcPr);
    elems := object_.Ps();
    for _,elem in elems do
        {self.}AppendChild(new PUnitDecorator(elem));
    elems := object_.Tbls();
    for _,elem in elems do
        {self.}AppendChild(new TblUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function TcPrUnitDecorator.Create(_obj: TcPr);
begin
    class(TcPr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TcPrUnitDecorator.GetObject();
begin
    return object_;
end;

function TcPrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildTcW) then
        {self.}XmlChildTcW := new TblWUnitDecorator(object_.XmlChildTcW);
    if not ifnil(object_.XmlChildGridSpan) then
        {self.}XmlChildGridSpan := new GridSpanUnitDecorator(object_.XmlChildGridSpan);
    if not ifnil(object_.XmlChildVMerge) then
        {self.}VMerge.Copy(object_.XmlChildVMerge);
    if not ifnil(object_.XmlChildVAlign) then
        {self.}XmlChildVAlign := new PureWValUnitDecorator(object_.XmlChildVAlign);
    if not ifnil(object_.XmlChildHideMark) then
        {self.}HideMark.Copy(object_.XmlChildHideMark);
    if not ifnil(object_.XmlChildShd) then
        {self.}XmlChildShd := new ShdUnitDecorator(object_.XmlChildShd);
    if not ifnil(object_.XmlChildTcBorders) then
        {self.}XmlChildTcBorders := new TcBordersUnitDecorator(object_.XmlChildTcBorders);
    if not ifnil(object_.XmlChildTextDirection) then
        {self.}XmlChildTextDirection := new PureWValUnitDecorator(object_.XmlChildTextDirection);
    tslassigning := tslassigning_backup;
end;

function TcBordersUnitDecorator.Create(_obj: TcBorders);
begin
    class(TcBorders).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TcBordersUnitDecorator.GetObject();
begin
    return object_;
end;

function TcBordersUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildTop) then
        {self.}XmlChildTop := new TcBorderUnitDecorator(object_.XmlChildTop);
    if not ifnil(object_.XmlChildLeft) then
        {self.}XmlChildLeft := new TcBorderUnitDecorator(object_.XmlChildLeft);
    if not ifnil(object_.XmlChildBottom) then
        {self.}XmlChildBottom := new TcBorderUnitDecorator(object_.XmlChildBottom);
    if not ifnil(object_.XmlChildRight) then
        {self.}XmlChildRight := new TcBorderUnitDecorator(object_.XmlChildRight);
    if not ifnil(object_.XmlChildTl2Br) then
        {self.}XmlChildTl2Br := new TcBorderUnitDecorator(object_.XmlChildTl2Br);
    if not ifnil(object_.XmlChildTr2Bl) then
        {self.}XmlChildTr2Bl := new TcBorderUnitDecorator(object_.XmlChildTr2Bl);
    if not ifnil(object_.XmlChildInsideH) then
        {self.}XmlChildInsideH := new TcBorderUnitDecorator(object_.XmlChildInsideH);
    if not ifnil(object_.XmlChildInsideV) then
        {self.}XmlChildInsideV := new TcBorderUnitDecorator(object_.XmlChildInsideV);
    tslassigning := tslassigning_backup;
end;

function TcBorderUnitDecorator.Create(_obj: TcBorder);
begin
    class(TcBorder).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TcBorderUnitDecorator.GetObject();
begin
    return object_;
end;

function TcBorderUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    if not ifnil(object_.XmlAttrColor) then
        {self.}Color := object_.XmlAttrColor.Value;
    if not ifnil(object_.XmlAttrSpace) then
        {self.}Space := object_.XmlAttrSpace.Value;
    if not ifnil(object_.XmlAttrThemeColor) then
        {self.}ThemeColor := object_.XmlAttrThemeColor.Value;
    if not ifnil(object_.XmlAttrThemeTint) then
        {self.}ThemeTint := object_.XmlAttrThemeTint.Value;
    if not ifnil(object_.XmlAttrSz) then
        {self.}Sz := TSSafeUnitConverter.EighthPointToPoints(object_.XmlAttrSz.Value);
    tslassigning := tslassigning_backup;
end;

function GridSpanUnitDecorator.Create(_obj: GridSpan);
begin
    class(GridSpan).Create();
    object_ := _obj;
    {self.}Convert();
end;

function GridSpanUnitDecorator.GetObject();
begin
    return object_;
end;

function GridSpanUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := TSSafeUnitConverter.ToInt(object_.XmlAttrVal.Value);
    tslassigning := tslassigning_backup;
end;

function SdtUnitDecorator.Create(_obj: Sdt);
begin
    class(Sdt).Create();
    object_ := _obj;
    {self.}Convert();
end;

function SdtUnitDecorator.GetObject();
begin
    return object_;
end;

function SdtUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildSdtPr) then
        {self.}XmlChildSdtPr := new SdtPrUnitDecorator(object_.XmlChildSdtPr);
    if not ifnil(object_.XmlChildSdtEndPr) then
        {self.}XmlChildSdtEndPr := new SdtEndPrUnitDecorator(object_.XmlChildSdtEndPr);
    if not ifnil(object_.XmlChildSdtContent) then
        {self.}XmlChildSdtContent := new SdtContentUnitDecorator(object_.XmlChildSdtContent);
    tslassigning := tslassigning_backup;
end;

function SdtPrUnitDecorator.Create(_obj: SdtPr);
begin
    class(SdtPr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function SdtPrUnitDecorator.GetObject();
begin
    return object_;
end;

function SdtPrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildRPr) then
        {self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
    if not ifnil(object_.XmlChildId) then
        {self.}XmlChildId := new PureWValUnitDecorator(object_.XmlChildId);
    if not ifnil(object_.XmlChildDocPartObj) then
        {self.}XmlChildDocPartObj := new DocPartObjUnitDecorator(object_.XmlChildDocPartObj);
    tslassigning := tslassigning_backup;
end;

function DocPartObjUnitDecorator.Create(_obj: DocPartObj);
begin
    class(DocPartObj).Create();
    object_ := _obj;
    {self.}Convert();
end;

function DocPartObjUnitDecorator.GetObject();
begin
    return object_;
end;

function DocPartObjUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildDocPartGallery) then
        {self.}XmlChildDocPartGallery := new PureWValUnitDecorator(object_.XmlChildDocPartGallery);
    if not ifnil(object_.XmlChildDocPartUnique) then
        {self.}XmlChildDocPartUnique := new PureValUnitDecorator(object_.XmlChildDocPartUnique);
    tslassigning := tslassigning_backup;
end;

function SdtEndPrUnitDecorator.Create(_obj: SdtEndPr);
begin
    class(SdtEndPr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function SdtEndPrUnitDecorator.GetObject();
begin
    return object_;
end;

function SdtEndPrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildRPr) then
        {self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
    tslassigning := tslassigning_backup;
end;

function SdtContentUnitDecorator.Create(_obj: SdtContent);
begin
    class(SdtContent).Create();
    object_ := _obj;
    {self.}Convert();
end;

function SdtContentUnitDecorator.GetObject();
begin
    return object_;
end;

function SdtContentUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    elems := object_.Ps();
    for _,elem in elems do
        {self.}AppendChild(new PUnitDecorator(elem));
    elems := object_.Rs();
    for _,elem in elems do
        {self.}AppendChild(new RUnitDecorator(elem));
    if not ifnil(object_.XmlChildSdt) then
        {self.}XmlChildSdt := new SdtUnitDecorator(object_.XmlChildSdt);
    tslassigning := tslassigning_backup;
end;

function SectPrUnitDecorator.Create(_obj: SectPr);
begin
    class(SectPr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function SectPrUnitDecorator.GetObject();
begin
    return object_;
end;

function SectPrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrRsidR) then
        {self.}RsidR := object_.XmlAttrRsidR.Value;
    if not ifnil(object_.XmlAttrRsidSect) then
        {self.}RsidSect := object_.XmlAttrRsidSect.Value;
    elems := object_.HeaderReferences();
    for _,elem in elems do
        {self.}AppendChild(new ReferenceUnitDecorator(elem));
    elems := object_.FooterReferences();
    for _,elem in elems do
        {self.}AppendChild(new ReferenceUnitDecorator(elem));
    if not ifnil(object_.XmlChildFootnotePr) then
        {self.}XmlChildFootnotePr := new FootnotePrUnitDecorator(object_.XmlChildFootnotePr);
    if not ifnil(object_.XmlChildEndnotePr) then
        {self.}XmlChildEndnotePr := new EndnotePrUnitDecorator(object_.XmlChildEndnotePr);
    if not ifnil(object_.XmlChildType) then
        {self.}XmlChildType := new PureWValUnitDecorator(object_.XmlChildType);
    if not ifnil(object_.XmlChildPgSz) then
        {self.}XmlChildPgSz := new PgSzUnitDecorator(object_.XmlChildPgSz);
    if not ifnil(object_.XmlChildPgMar) then
        {self.}XmlChildPgMar := new PgMarUnitDecorator(object_.XmlChildPgMar);
    if not ifnil(object_.XmlChildPgNumType) then
        {self.}XmlChildPgNumType := new PgNumTypeUnitDecorator(object_.XmlChildPgNumType);
    if not ifnil(object_.XmlChildCols) then
        {self.}XmlChildCols := new ColsUnitDecorator(object_.XmlChildCols);
    if not ifnil(object_.XmlChildTitlePg) then
        {self.}TitlePg.Copy(object_.XmlChildTitlePg);
    if not ifnil(object_.XmlChildDocGrid) then
        {self.}XmlChildDocGrid := new DocGridUnitDecorator(object_.XmlChildDocGrid);
    if not ifnil(object_.XmlChildTextDirection) then
        {self.}XmlChildTextDirection := new PureWValUnitDecorator(object_.XmlChildTextDirection);
    tslassigning := tslassigning_backup;
end;

function ReferenceUnitDecorator.Create(_obj: Reference);
begin
    class(Reference).Create();
    object_ := _obj;
    {self.}Convert();
end;

function ReferenceUnitDecorator.GetObject();
begin
    return object_;
end;

function ReferenceUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrType) then
        {self.}Type := object_.XmlAttrType.Value;
    if not ifnil(object_.XmlAttrId) then
        {self.}Id := object_.XmlAttrId.Value;
    tslassigning := tslassigning_backup;
end;

function PgNumTypeUnitDecorator.Create(_obj: PgNumType);
begin
    class(PgNumType).Create();
    object_ := _obj;
    {self.}Convert();
end;

function PgNumTypeUnitDecorator.GetObject();
begin
    return object_;
end;

function PgNumTypeUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrStart) then
        {self.}Start := TSSafeUnitConverter.ToInt(object_.XmlAttrStart.Value);
    tslassigning := tslassigning_backup;
end;

function PgSzUnitDecorator.Create(_obj: PgSz);
begin
    class(PgSz).Create();
    object_ := _obj;
    {self.}Convert();
end;

function PgSzUnitDecorator.GetObject();
begin
    return object_;
end;

function PgSzUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrW) then
        {self.}W := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrW.Value);
    if not ifnil(object_.XmlAttrH) then
        {self.}H := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrH.Value);
    if not ifnil(object_.XmlAttrOrient) then
        {self.}Orient := object_.XmlAttrOrient.Value;
    if not ifnil(object_.XmlAttrCode) then
        {self.}Code := object_.XmlAttrCode.Value;
    tslassigning := tslassigning_backup;
end;

function PgMarUnitDecorator.Create(_obj: PgMar);
begin
    class(PgMar).Create();
    object_ := _obj;
    {self.}Convert();
end;

function PgMarUnitDecorator.GetObject();
begin
    return object_;
end;

function PgMarUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrTop) then
        {self.}Top := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrTop.Value);
    if not ifnil(object_.XmlAttrRight) then
        {self.}Right := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrRight.Value);
    if not ifnil(object_.XmlAttrBottom) then
        {self.}Bottom := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrBottom.Value);
    if not ifnil(object_.XmlAttrLeft) then
        {self.}Left := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrLeft.Value);
    if not ifnil(object_.XmlAttrHeader) then
        {self.}Header := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrHeader.Value);
    if not ifnil(object_.XmlAttrFooter) then
        {self.}Footer := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrFooter.Value);
    if not ifnil(object_.XmlAttrGutter) then
        {self.}Gutter := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrGutter.Value);
    tslassigning := tslassigning_backup;
end;

function ColsUnitDecorator.Create(_obj: Cols);
begin
    class(Cols).Create();
    object_ := _obj;
    {self.}Convert();
end;

function ColsUnitDecorator.GetObject();
begin
    return object_;
end;

function ColsUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrNum) then
        {self.}Num := TSSafeUnitConverter.ToInt(object_.XmlAttrNum.Value);
    if not ifnil(object_.XmlAttrSpace) then
        {self.}Space := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrSpace.Value);
    if not ifnil(object_.XmlAttrEqualWidth) then
        {self.}EqualWidth := object_.XmlAttrEqualWidth.Value;
    elems := object_.Cols();
    for _,elem in elems do
        {self.}AppendChild(new ColUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function ColUnitDecorator.Create(_obj: Col);
begin
    class(Col).Create();
    object_ := _obj;
    {self.}Convert();
end;

function ColUnitDecorator.GetObject();
begin
    return object_;
end;

function ColUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrW) then
        {self.}W := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrW.Value);
    if not ifnil(object_.XmlAttrSpace) then
        {self.}Space := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrSpace.Value);
    tslassigning := tslassigning_backup;
end;

function DocGridUnitDecorator.Create(_obj: DocGrid);
begin
    class(DocGrid).Create();
    object_ := _obj;
    {self.}Convert();
end;

function DocGridUnitDecorator.GetObject();
begin
    return object_;
end;

function DocGridUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrType) then
        {self.}Type := object_.XmlAttrType.Value;
    if not ifnil(object_.XmlAttrLinePitch) then
        {self.}LinePitch := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrLinePitch.Value);
    tslassigning := tslassigning_backup;
end;

function EndnotesUnitDecorator.Create(_obj: Endnotes);
begin
    class(Endnotes).Create();
    object_ := _obj;
    {self.}Convert();
end;

function EndnotesUnitDecorator.GetObject();
begin
    return object_;
end;

function EndnotesUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrIgnorable) then
        {self.}Ignorable := object_.XmlAttrIgnorable.Value;
    elems := object_.Endnotes();
    for _,elem in elems do
        {self.}AppendChild(new EndnoteUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function EndnoteUnitDecorator.Create(_obj: Endnote);
begin
    class(Endnote).Create();
    object_ := _obj;
    {self.}Convert();
end;

function EndnoteUnitDecorator.GetObject();
begin
    return object_;
end;

function EndnoteUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrType) then
        {self.}Type := object_.XmlAttrType.Value;
    if not ifnil(object_.XmlAttrId) then
        {self.}Id := object_.XmlAttrId.Value;
    elems := object_.Ps();
    for _,elem in elems do
        {self.}AppendChild(new PUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function FootnotesUnitDecorator.Create(_obj: Footnotes);
begin
    class(Footnotes).Create();
    object_ := _obj;
    {self.}Convert();
end;

function FootnotesUnitDecorator.GetObject();
begin
    return object_;
end;

function FootnotesUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrIgnorable) then
        {self.}Ignorable := object_.XmlAttrIgnorable.Value;
    elems := object_.Footnotes();
    for _,elem in elems do
        {self.}AppendChild(new FootnoteUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function FootnoteUnitDecorator.Create(_obj: Footnote);
begin
    class(Footnote).Create();
    object_ := _obj;
    {self.}Convert();
end;

function FootnoteUnitDecorator.GetObject();
begin
    return object_;
end;

function FootnoteUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrType) then
        {self.}Type := object_.XmlAttrType.Value;
    if not ifnil(object_.XmlAttrId) then
        {self.}Id := object_.XmlAttrId.Value;
    elems := object_.Ps();
    for _,elem in elems do
        {self.}AppendChild(new PUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function FontsUnitDecorator.Create(_obj: Fonts);
begin
    class(Fonts).Create();
    object_ := _obj;
    {self.}Convert();
end;

function FontsUnitDecorator.GetObject();
begin
    return object_;
end;

function FontsUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrIgnorable) then
        {self.}Ignorable := object_.XmlAttrIgnorable.Value;
    elems := object_.Fonts();
    for _,elem in elems do
        {self.}AppendChild(new FontUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function FontUnitDecorator.Create(_obj: Font);
begin
    class(Font).Create();
    object_ := _obj;
    {self.}Convert();
end;

function FontUnitDecorator.GetObject();
begin
    return object_;
end;

function FontUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrName) then
        {self.}Name := object_.XmlAttrName.Value;
    if not ifnil(object_.XmlChildAltName) then
        {self.}XmlChildAltName := new PureWValUnitDecorator(object_.XmlChildAltName);
    if not ifnil(object_.XmlChildPanosel) then
        {self.}XmlChildPanosel := new PureWValUnitDecorator(object_.XmlChildPanosel);
    if not ifnil(object_.XmlChildCharset) then
        {self.}XmlChildCharset := new PureWValUnitDecorator(object_.XmlChildCharset);
    if not ifnil(object_.XmlChildFamily) then
        {self.}XmlChildFamily := new PureWValUnitDecorator(object_.XmlChildFamily);
    if not ifnil(object_.XmlChildPitch) then
        {self.}XmlChildPitch := new PureWValUnitDecorator(object_.XmlChildPitch);
    if not ifnil(object_.XmlChildSig) then
        {self.}XmlChildSig := new SigUnitDecorator(object_.XmlChildSig);
    tslassigning := tslassigning_backup;
end;

function SigUnitDecorator.Create(_obj: Sig);
begin
    class(Sig).Create();
    object_ := _obj;
    {self.}Convert();
end;

function SigUnitDecorator.GetObject();
begin
    return object_;
end;

function SigUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrUsb0) then
        {self.}Usb0 := object_.XmlAttrUsb0.Value;
    if not ifnil(object_.XmlAttrUsb1) then
        {self.}Usb1 := object_.XmlAttrUsb1.Value;
    if not ifnil(object_.XmlAttrUsb2) then
        {self.}Usb2 := object_.XmlAttrUsb2.Value;
    if not ifnil(object_.XmlAttrUsb3) then
        {self.}Usb3 := object_.XmlAttrUsb3.Value;
    if not ifnil(object_.XmlAttrCsb0) then
        {self.}Csb0 := object_.XmlAttrCsb0.Value;
    if not ifnil(object_.XmlAttrCsb1) then
        {self.}Csb1 := object_.XmlAttrCsb1.Value;
    tslassigning := tslassigning_backup;
end;

function SettingsUnitDecorator.Create(_obj: Settings);
begin
    class(Settings).Create();
    object_ := _obj;
    {self.}Convert();
end;

function SettingsUnitDecorator.GetObject();
begin
    return object_;
end;

function SettingsUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrIgnorable) then
        {self.}Ignorable := object_.XmlAttrIgnorable.Value;
    if not ifnil(object_.XmlAttrIgnorable) then
        {self.}Ignorable := object_.XmlAttrIgnorable.Value;
    if not ifnil(object_.XmlAttrIgnorable) then
        {self.}Ignorable := object_.XmlAttrIgnorable.Value;
    if not ifnil(object_.XmlAttrPr) then
        {self.}Pr := object_.XmlAttrPr.Value;
    if not ifnil(object_.XmlAttrPr) then
        {self.}Pr := object_.XmlAttrPr.Value;
    if not ifnil(object_.XmlAttrSig) then
        {self.}Sig := object_.XmlAttrSig.Value;
    if not ifnil(object_.XmlAttrSig) then
        {self.}Sig := object_.XmlAttrSig.Value;
    if not ifnil(object_.XmlAttrSig) then
        {self.}Sig := object_.XmlAttrSig.Value;
    if not ifnil(object_.XmlChildDocId) then
        {self.}XmlChildDocId := new PureWValUnitDecorator(object_.XmlChildDocId);
    if not ifnil(object_.XmlChildDocId) then
        {self.}XmlChildDocId := new PureWValUnitDecorator(object_.XmlChildDocId);
    if not ifnil(object_.XmlChildDocId) then
        {self.}XmlChildDocId := new PureWValUnitDecorator(object_.XmlChildDocId);
    if not ifnil(object_.XmlChildChartTrackingRefBased) then
        {self.}ChartTrackingRefBased.Copy(object_.XmlChildChartTrackingRefBased);
    tslassigning := tslassigning_backup;
end;

function ZoomUnitDecorator.Create(_obj: Zoom);
begin
    class(Zoom).Create();
    object_ := _obj;
    {self.}Convert();
end;

function ZoomUnitDecorator.GetObject();
begin
    return object_;
end;

function ZoomUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrPercent) then
        {self.}Percent := object_.XmlAttrPercent.Value;
    tslassigning := tslassigning_backup;
end;

function HdrShapeDefaultsUnitDecorator.Create(_obj: HdrShapeDefaults);
begin
    class(HdrShapeDefaults).Create();
    object_ := _obj;
    {self.}Convert();
end;

function HdrShapeDefaultsUnitDecorator.GetObject();
begin
    return object_;
end;

function HdrShapeDefaultsUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildShapeDefaults) then
        {self.}XmlChildShapeDefaults := new ShapeDefaultsUnitDecorator(object_.XmlChildShapeDefaults);
    tslassigning := tslassigning_backup;
end;

function ShapeDefaultsUnitDecorator.Create(_obj: ShapeDefaults);
begin
    class(ShapeDefaults).Create();
    object_ := _obj;
    {self.}Convert();
end;

function ShapeDefaultsUnitDecorator.GetObject();
begin
    return object_;
end;

function ShapeDefaultsUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrExt) then
        {self.}Ext := object_.XmlAttrExt.Value;
    if not ifnil(object_.XmlAttrSpidmax) then
        {self.}Spidmax := object_.XmlAttrSpidmax.Value;
    tslassigning := tslassigning_backup;
end;

function FootnotePrUnitDecorator.Create(_obj: FootnotePr);
begin
    class(FootnotePr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function FootnotePrUnitDecorator.GetObject();
begin
    return object_;
end;

function FootnotePrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildPos) then
        {self.}XmlChildPos := new PureWValUnitDecorator(object_.XmlChildPos);
    if not ifnil(object_.XmlChildNumFmt) then
        {self.}XmlChildNumFmt := new PureWValUnitDecorator(object_.XmlChildNumFmt);
    if not ifnil(object_.XmlChildNumStart) then
        {self.}XmlChildNumStart := new PureWValUnitDecorator(object_.XmlChildNumStart);
    if not ifnil(object_.XmlChildNumRestart) then
        {self.}XmlChildNumRestart := new PureWValUnitDecorator(object_.XmlChildNumRestart);
    elems := object_.Footnotes();
    for _,elem in elems do
        {self.}AppendChild(new FootnoteUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function EndnotePrUnitDecorator.Create(_obj: EndnotePr);
begin
    class(EndnotePr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function EndnotePrUnitDecorator.GetObject();
begin
    return object_;
end;

function EndnotePrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildPos) then
        {self.}XmlChildPos := new PureWValUnitDecorator(object_.XmlChildPos);
    if not ifnil(object_.XmlChildNumFmt) then
        {self.}XmlChildNumFmt := new PureWValUnitDecorator(object_.XmlChildNumFmt);
    if not ifnil(object_.XmlChildNumStart) then
        {self.}XmlChildNumStart := new PureWValUnitDecorator(object_.XmlChildNumStart);
    if not ifnil(object_.XmlChildNumRestart) then
        {self.}XmlChildNumRestart := new PureWValUnitDecorator(object_.XmlChildNumRestart);
    elems := object_.Footnotes();
    for _,elem in elems do
        {self.}AppendChild(new FootnoteUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function CompatUnitDecorator.Create(_obj: Compat);
begin
    class(Compat).Create();
    object_ := _obj;
    {self.}Convert();
end;

function CompatUnitDecorator.GetObject();
begin
    return object_;
end;

function CompatUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildSpaceForUL) then
        {self.}SpaceForUL.Copy(object_.XmlChildSpaceForUL);
    if not ifnil(object_.XmlChildBalanceSingleByteDoubleByteWidth) then
        {self.}BalanceSingleByteDoubleByteWidth.Copy(object_.XmlChildBalanceSingleByteDoubleByteWidth);
    if not ifnil(object_.XmlChildDoNotLeaveBackslashAlone) then
        {self.}DoNotLeaveBackslashAlone.Copy(object_.XmlChildDoNotLeaveBackslashAlone);
    if not ifnil(object_.XmlChildUlTrailSpace) then
        {self.}UlTrailSpace.Copy(object_.XmlChildUlTrailSpace);
    if not ifnil(object_.XmlChildDoNotExpandShiftReturn) then
        {self.}DoNotExpandShiftReturn.Copy(object_.XmlChildDoNotExpandShiftReturn);
    if not ifnil(object_.XmlChildAdjustLineHeightInTable) then
        {self.}AdjustLineHeightInTable.Copy(object_.XmlChildAdjustLineHeightInTable);
    if not ifnil(object_.XmlChildUseFELayout) then
        {self.}UseFELayout.Copy(object_.XmlChildUseFELayout);
    elems := object_.CompatSettings();
    for _,elem in elems do
        {self.}AppendChild(new CompatSettingUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function CompatSettingUnitDecorator.Create(_obj: CompatSetting);
begin
    class(CompatSetting).Create();
    object_ := _obj;
    {self.}Convert();
end;

function CompatSettingUnitDecorator.GetObject();
begin
    return object_;
end;

function CompatSettingUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrName) then
        {self.}Name := object_.XmlAttrName.Value;
    if not ifnil(object_.XmlAttrUri) then
        {self.}Uri := object_.XmlAttrUri.Value;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    tslassigning := tslassigning_backup;
end;

function RsidsUnitDecorator.Create(_obj: Rsids);
begin
    class(Rsids).Create();
    object_ := _obj;
    {self.}Convert();
end;

function RsidsUnitDecorator.GetObject();
begin
    return object_;
end;

function RsidsUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildRsidRoot) then
        {self.}XmlChildRsidRoot := new PureWValUnitDecorator(object_.XmlChildRsidRoot);
    elems := object_.Rsids();
    for _,elem in elems do
        {self.}AppendChild(new PureWValUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function ThemeFontLangUnitDecorator.Create(_obj: ThemeFontLang);
begin
    class(ThemeFontLang).Create();
    object_ := _obj;
    {self.}Convert();
end;

function ThemeFontLangUnitDecorator.GetObject();
begin
    return object_;
end;

function ThemeFontLangUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrVal) then
        {self.}Val := object_.XmlAttrVal.Value;
    if not ifnil(object_.XmlAttrEastAsia) then
        {self.}EastAsia := object_.XmlAttrEastAsia.Value;
    tslassigning := tslassigning_backup;
end;

function ClrSchemeMappingUnitDecorator.Create(_obj: ClrSchemeMapping);
begin
    class(ClrSchemeMapping).Create();
    object_ := _obj;
    {self.}Convert();
end;

function ClrSchemeMappingUnitDecorator.GetObject();
begin
    return object_;
end;

function ClrSchemeMappingUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrBg1) then
        {self.}Bg1 := object_.XmlAttrBg1.Value;
    if not ifnil(object_.XmlAttrT1) then
        {self.}T1 := object_.XmlAttrT1.Value;
    if not ifnil(object_.XmlAttrBg2) then
        {self.}Bg2 := object_.XmlAttrBg2.Value;
    if not ifnil(object_.XmlAttrT2) then
        {self.}T2 := object_.XmlAttrT2.Value;
    if not ifnil(object_.XmlAttrAccent1) then
        {self.}Accent1 := object_.XmlAttrAccent1.Value;
    if not ifnil(object_.XmlAttrAccent2) then
        {self.}Accent2 := object_.XmlAttrAccent2.Value;
    if not ifnil(object_.XmlAttrAccent3) then
        {self.}Accent3 := object_.XmlAttrAccent3.Value;
    if not ifnil(object_.XmlAttrAccent4) then
        {self.}Accent4 := object_.XmlAttrAccent4.Value;
    if not ifnil(object_.XmlAttrAccent5) then
        {self.}Accent5 := object_.XmlAttrAccent5.Value;
    if not ifnil(object_.XmlAttrAccent6) then
        {self.}Accent6 := object_.XmlAttrAccent6.Value;
    if not ifnil(object_.XmlAttrHyperLink) then
        {self.}HyperLink := object_.XmlAttrHyperLink.Value;
    if not ifnil(object_.XmlAttrFollowedHyperlink) then
        {self.}FollowedHyperlink := object_.XmlAttrFollowedHyperlink.Value;
    tslassigning := tslassigning_backup;
end;

function ShapeDefaults2UnitDecorator.Create(_obj: ShapeDefaults2);
begin
    class(ShapeDefaults2).Create();
    object_ := _obj;
    {self.}Convert();
end;

function ShapeDefaults2UnitDecorator.GetObject();
begin
    return object_;
end;

function ShapeDefaults2UnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildShapeDefaults) then
        {self.}XmlChildShapeDefaults := new ShapeDefaultsUnitDecorator(object_.XmlChildShapeDefaults);
    if not ifnil(object_.XmlChildShapeLayout) then
        {self.}XmlChildShapeLayout := new ShapeLayoutUnitDecorator(object_.XmlChildShapeLayout);
    tslassigning := tslassigning_backup;
end;

function ShapeLayoutUnitDecorator.Create(_obj: ShapeLayout);
begin
    class(ShapeLayout).Create();
    object_ := _obj;
    {self.}Convert();
end;

function ShapeLayoutUnitDecorator.GetObject();
begin
    return object_;
end;

function ShapeLayoutUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrExt) then
        {self.}Ext := object_.XmlAttrExt.Value;
    if not ifnil(object_.XmlChildIdMap) then
        {self.}XmlChildIdMap := new IdMapUnitDecorator(object_.XmlChildIdMap);
    tslassigning := tslassigning_backup;
end;

function IdMapUnitDecorator.Create(_obj: IdMap);
begin
    class(IdMap).Create();
    object_ := _obj;
    {self.}Convert();
end;

function IdMapUnitDecorator.GetObject();
begin
    return object_;
end;

function IdMapUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrExt) then
        {self.}Ext := object_.XmlAttrExt.Value;
    if not ifnil(object_.XmlAttrData) then
        {self.}Data := object_.XmlAttrData.Value;
    tslassigning := tslassigning_backup;
end;

function StylesUnitDecorator.Create(_obj: Styles);
begin
    class(Styles).Create();
    object_ := _obj;
    {self.}Convert();
end;

function StylesUnitDecorator.GetObject();
begin
    return object_;
end;

function StylesUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrIgnorable) then
        {self.}Ignorable := object_.XmlAttrIgnorable.Value;
    if not ifnil(object_.XmlChildDocDefaults) then
        {self.}XmlChildDocDefaults := new DocDefaultsUnitDecorator(object_.XmlChildDocDefaults);
    if not ifnil(object_.XmlChildLatenStyles) then
        {self.}XmlChildLatenStyles := new LatenStylesUnitDecorator(object_.XmlChildLatenStyles);
    elems := object_.Styles();
    for _,elem in elems do
        {self.}AppendChild(new StyleUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function DocDefaultsUnitDecorator.Create(_obj: DocDefaults);
begin
    class(DocDefaults).Create();
    object_ := _obj;
    {self.}Convert();
end;

function DocDefaultsUnitDecorator.GetObject();
begin
    return object_;
end;

function DocDefaultsUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildRPrDefault) then
        {self.}XmlChildRPrDefault := new RPrDefaultUnitDecorator(object_.XmlChildRPrDefault);
    if not ifnil(object_.XmlChildPPrDefault) then
        {self.}XmlChildPPrDefault := new PPrDefaultUnitDecorator(object_.XmlChildPPrDefault);
    tslassigning := tslassigning_backup;
end;

function RPrDefaultUnitDecorator.Create(_obj: RPrDefault);
begin
    class(RPrDefault).Create();
    object_ := _obj;
    {self.}Convert();
end;

function RPrDefaultUnitDecorator.GetObject();
begin
    return object_;
end;

function RPrDefaultUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildRPr) then
        {self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
    tslassigning := tslassigning_backup;
end;

function PPrDefaultUnitDecorator.Create(_obj: PPrDefault);
begin
    class(PPrDefault).Create();
    object_ := _obj;
    {self.}Convert();
end;

function PPrDefaultUnitDecorator.GetObject();
begin
    return object_;
end;

function PPrDefaultUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildPPr) then
        {self.}XmlChildPPr := new PPrUnitDecorator(object_.XmlChildPPr);
    tslassigning := tslassigning_backup;
end;

function LatenStylesUnitDecorator.Create(_obj: LatenStyles);
begin
    class(LatenStyles).Create();
    object_ := _obj;
    {self.}Convert();
end;

function LatenStylesUnitDecorator.GetObject();
begin
    return object_;
end;

function LatenStylesUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrDefLickedState) then
        {self.}DefLickedState := object_.XmlAttrDefLickedState.Value;
    if not ifnil(object_.XmlAttrDefUIPriority) then
        {self.}DefUIPriority := object_.XmlAttrDefUIPriority.Value;
    if not ifnil(object_.XmlAttrDefSemiHidden) then
        {self.}DefSemiHidden := object_.XmlAttrDefSemiHidden.Value;
    if not ifnil(object_.XmlAttrDefUnhideWhenUsed) then
        {self.}DefUnhideWhenUsed := object_.XmlAttrDefUnhideWhenUsed.Value;
    if not ifnil(object_.XmlAttrDefQFormat) then
        {self.}DefQFormat := object_.XmlAttrDefQFormat.Value;
    if not ifnil(object_.XmlAttrCount) then
        {self.}Count := object_.XmlAttrCount.Value;
    elems := object_.LsdExceptions();
    for _,elem in elems do
        {self.}AppendChild(new LsdExceptionUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function LsdExceptionUnitDecorator.Create(_obj: LsdException);
begin
    class(LsdException).Create();
    object_ := _obj;
    {self.}Convert();
end;

function LsdExceptionUnitDecorator.GetObject();
begin
    return object_;
end;

function LsdExceptionUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrName) then
        {self.}Name := object_.XmlAttrName.Value;
    if not ifnil(object_.XmlAttrUIPriority) then
        {self.}UIPriority := object_.XmlAttrUIPriority.Value;
    if not ifnil(object_.XmlAttrSemiHidden) then
        {self.}SemiHidden := object_.XmlAttrSemiHidden.Value;
    if not ifnil(object_.XmlAttrUnhideWhenUsed) then
        {self.}UnhideWhenUsed := object_.XmlAttrUnhideWhenUsed.Value;
    if not ifnil(object_.XmlAttrQFormat) then
        {self.}QFormat := object_.XmlAttrQFormat.Value;
    tslassigning := tslassigning_backup;
end;

function StyleUnitDecorator.Create(_obj: Style);
begin
    class(Style).Create();
    object_ := _obj;
    {self.}Convert();
end;

function StyleUnitDecorator.GetObject();
begin
    return object_;
end;

function StyleUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrType) then
        {self.}Type := object_.XmlAttrType.Value;
    if not ifnil(object_.XmlAttrDefault) then
        {self.}Default := object_.XmlAttrDefault.Value;
    if not ifnil(object_.XmlAttrStyleId) then
        {self.}StyleId := object_.XmlAttrStyleId.Value;
    if not ifnil(object_.XmlChildName) then
        {self.}XmlChildName := new PureWValUnitDecorator(object_.XmlChildName);
    if not ifnil(object_.XmlChildBasedOn) then
        {self.}XmlChildBasedOn := new PureWValUnitDecorator(object_.XmlChildBasedOn);
    if not ifnil(object_.XmlChildNext) then
        {self.}XmlChildNext := new PureWValUnitDecorator(object_.XmlChildNext);
    if not ifnil(object_.XmlChildAutoRedefine) then
        {self.}XmlChildAutoRedefine := new PureWValUnitDecorator(object_.XmlChildAutoRedefine);
    if not ifnil(object_.XmlChildLink) then
        {self.}XmlChildLink := new PureWValUnitDecorator(object_.XmlChildLink);
    if not ifnil(object_.XmlChildUIPriority) then
        {self.}XmlChildUIPriority := new PureWValUnitDecorator(object_.XmlChildUIPriority);
    if not ifnil(object_.XmlChildSemiHidden) then
        {self.}SemiHidden.Copy(object_.XmlChildSemiHidden);
    if not ifnil(object_.XmlChildUnhideWhenUsed) then
        {self.}UnhideWhenUsed.Copy(object_.XmlChildUnhideWhenUsed);
    if not ifnil(object_.XmlChildQFormat) then
        {self.}QFormat.Copy(object_.XmlChildQFormat);
    if not ifnil(object_.XmlChildRsid) then
        {self.}XmlChildRsid := new PureWValUnitDecorator(object_.XmlChildRsid);
    if not ifnil(object_.XmlChildPPr) then
        {self.}XmlChildPPr := new PPrUnitDecorator(object_.XmlChildPPr);
    if not ifnil(object_.XmlChildRPr) then
        {self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
    if not ifnil(object_.XmlChildTblPr) then
        {self.}XmlChildTblPr := new TblPrUnitDecorator(object_.XmlChildTblPr);
    if not ifnil(object_.XmlChildTrPr) then
        {self.}XmlChildTrPr := new TrPrUnitDecorator(object_.XmlChildTrPr);
    if not ifnil(object_.XmlChildTcPr) then
        {self.}XmlChildTcPr := new TcPrUnitDecorator(object_.XmlChildTcPr);
    elems := object_.TblStylePrs();
    for _,elem in elems do
        {self.}AppendChild(new TblStylePrUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function TblStylePrUnitDecorator.Create(_obj: TblStylePr);
begin
    class(TblStylePr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TblStylePrUnitDecorator.GetObject();
begin
    return object_;
end;

function TblStylePrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrType) then
        {self.}Type := object_.XmlAttrType.Value;
    if not ifnil(object_.XmlChildPPr) then
        {self.}XmlChildPPr := new PPrUnitDecorator(object_.XmlChildPPr);
    if not ifnil(object_.XmlChildRPr) then
        {self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
    if not ifnil(object_.XmlChildTblPr) then
        {self.}XmlChildTblPr := new TblPrUnitDecorator(object_.XmlChildTblPr);
    if not ifnil(object_.XmlChildTrPr) then
        {self.}XmlChildTrPr := new TrPrUnitDecorator(object_.XmlChildTrPr);
    if not ifnil(object_.XmlChildTcPr) then
        {self.}XmlChildTcPr := new TcPrUnitDecorator(object_.XmlChildTcPr);
    tslassigning := tslassigning_backup;
end;

function TblIndUnitDecorator.Create(_obj: TblInd);
begin
    class(TblInd).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TblIndUnitDecorator.GetObject();
begin
    return object_;
end;

function TblIndUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrW) then
        {self.}W := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrW.Value);
    if not ifnil(object_.XmlAttrType) then
        {self.}Type := object_.XmlAttrType.Value;
    tslassigning := tslassigning_backup;
end;

function TblCellMarUnitDecorator.Create(_obj: TblCellMar);
begin
    class(TblCellMar).Create();
    object_ := _obj;
    {self.}Convert();
end;

function TblCellMarUnitDecorator.GetObject();
begin
    return object_;
end;

function TblCellMarUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildTop) then
        {self.}XmlChildTop := new TblIndUnitDecorator(object_.XmlChildTop);
    if not ifnil(object_.XmlChildLeft) then
        {self.}XmlChildLeft := new TblIndUnitDecorator(object_.XmlChildLeft);
    if not ifnil(object_.XmlChildBottom) then
        {self.}XmlChildBottom := new TblIndUnitDecorator(object_.XmlChildBottom);
    if not ifnil(object_.XmlChildRight) then
        {self.}XmlChildRight := new TblIndUnitDecorator(object_.XmlChildRight);
    tslassigning := tslassigning_backup;
end;

function WebSettingsUnitDecorator.Create(_obj: WebSettings);
begin
    class(WebSettings).Create();
    object_ := _obj;
    {self.}Convert();
end;

function WebSettingsUnitDecorator.GetObject();
begin
    return object_;
end;

function WebSettingsUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrIgnorable) then
        {self.}Ignorable := object_.XmlAttrIgnorable.Value;
    if not ifnil(object_.XmlChildOptimizeForBrowser) then
        {self.}OptimizeForBrowser.Copy(object_.XmlChildOptimizeForBrowser);
    if not ifnil(object_.XmlChildAllowPNG) then
        {self.}AllowPNG.Copy(object_.XmlChildAllowPNG);
    tslassigning := tslassigning_backup;
end;

function AlternateContentUnitDecorator.Create(_obj: AlternateContent);
begin
    class(AlternateContent).Create();
    object_ := _obj;
    {self.}Convert();
end;

function AlternateContentUnitDecorator.GetObject();
begin
    return object_;
end;

function AlternateContentUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildChoice) then
        {self.}XmlChildChoice := new ChoiceUnitDecorator(object_.XmlChildChoice);
    if not ifnil(object_.XmlChildFallback) then
        {self.}XmlChildFallback := new FallbackUnitDecorator(object_.XmlChildFallback);
    tslassigning := tslassigning_backup;
end;

function ChoiceUnitDecorator.Create(_obj: Choice);
begin
    class(Choice).Create();
    object_ := _obj;
    {self.}Convert();
end;

function ChoiceUnitDecorator.GetObject();
begin
    return object_;
end;

function ChoiceUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrRequires) then
        {self.}Requires := object_.XmlAttrRequires.Value;
    if not ifnil(object_.XmlChildStyle) then
        {self.}XmlChildStyle := new PureValUnitDecorator(object_.XmlChildStyle);
    if not ifnil(object_.XmlChildDrawing) then
        {self.}XmlChildDrawing := new DrawingUnitDecorator(object_.XmlChildDrawing);
    tslassigning := tslassigning_backup;
end;

function FallbackUnitDecorator.Create(_obj: Fallback);
begin
    class(Fallback).Create();
    object_ := _obj;
    {self.}Convert();
end;

function FallbackUnitDecorator.GetObject();
begin
    return object_;
end;

function FallbackUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildStyle) then
        {self.}XmlChildStyle := new PureValUnitDecorator(object_.XmlChildStyle);
    if not ifnil(object_.XmlChildPict) then
        {self.}XmlChildPict := new PictUnitDecorator(object_.XmlChildPict);
    tslassigning := tslassigning_backup;
end;

function PictUnitDecorator.Create(_obj: Pict);
begin
    class(Pict).Create();
    object_ := _obj;
    {self.}Convert();
end;

function PictUnitDecorator.GetObject();
begin
    return object_;
end;

function PictUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlChildShapetype) then
        {self.}XmlChildShapetype := new ShapetypeUnitDecorator(object_.XmlChildShapetype);
    if not ifnil(object_.XmlChildShape) then
        {self.}XmlChildShape := new ShapeUnitDecorator(object_.XmlChildShape);
    if not ifnil(object_.XmlChildControl) then
        {self.}XmlChildControl := new ControlUnitDecorator(object_.XmlChildControl);
    tslassigning := tslassigning_backup;
end;

function ControlUnitDecorator.Create(_obj: Control);
begin
    class(Control).Create();
    object_ := _obj;
    {self.}Convert();
end;

function ControlUnitDecorator.GetObject();
begin
    return object_;
end;

function ControlUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrId) then
        {self.}Id := object_.XmlAttrId.Value;
    if not ifnil(object_.XmlAttrShapeid) then
        {self.}Shapeid := object_.XmlAttrShapeid.Value;
    if not ifnil(object_.XmlAttrname) then
        {self.}name := object_.XmlAttrname.Value;
    tslassigning := tslassigning_backup;
end;

function FtrUnitDecorator.Create(_obj: Ftr);
begin
    class(Ftr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function FtrUnitDecorator.GetObject();
begin
    return object_;
end;

function FtrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrIgnorable) then
        {self.}Ignorable := object_.XmlAttrIgnorable.Value;
    elems := object_.Ps();
    for _,elem in elems do
        {self.}AppendChild(new PUnitDecorator(elem));
    if not ifnil(object_.XmlChildSdt) then
        {self.}XmlChildSdt := new SdtUnitDecorator(object_.XmlChildSdt);
    tslassigning := tslassigning_backup;
end;

function HdrUnitDecorator.Create(_obj: Hdr);
begin
    class(Hdr).Create();
    object_ := _obj;
    {self.}Convert();
end;

function HdrUnitDecorator.GetObject();
begin
    return object_;
end;

function HdrUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrIgnorable) then
        {self.}Ignorable := object_.XmlAttrIgnorable.Value;
    elems := object_.Ps();
    for _,elem in elems do
        {self.}AppendChild(new PUnitDecorator(elem));
    if not ifnil(object_.XmlChildSdt) then
        {self.}XmlChildSdt := new SdtUnitDecorator(object_.XmlChildSdt);
    tslassigning := tslassigning_backup;
end;

function CommentsUnitDecorator.Create(_obj: Comments);
begin
    class(Comments).Create();
    object_ := _obj;
    {self.}Convert();
end;

function CommentsUnitDecorator.GetObject();
begin
    return object_;
end;

function CommentsUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrIgnorable) then
        {self.}Ignorable := object_.XmlAttrIgnorable.Value;
    elems := object_.Comments();
    for _,elem in elems do
        {self.}AppendChild(new CommentUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function CommentUnitDecorator.Create(_obj: Comment);
begin
    class(Comment).Create();
    object_ := _obj;
    {self.}Convert();
end;

function CommentUnitDecorator.GetObject();
begin
    return object_;
end;

function CommentUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrAuthor) then
        {self.}Author := object_.XmlAttrAuthor.Value;
    if not ifnil(object_.XmlAttrDate) then
        {self.}Date := object_.XmlAttrDate.Value;
    if not ifnil(object_.XmlAttrId) then
        {self.}Id := object_.XmlAttrId.Value;
    elems := object_.Ps();
    for _,elem in elems do
        {self.}AppendChild(new PUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function NumberingUnitDecorator.Create(_obj: Numbering);
begin
    class(Numbering).Create();
    object_ := _obj;
    {self.}Convert();
end;

function NumberingUnitDecorator.GetObject();
begin
    return object_;
end;

function NumberingUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrIgnorable) then
        {self.}Ignorable := object_.XmlAttrIgnorable.Value;
    elems := object_.AbstractNums();
    for _,elem in elems do
        {self.}AppendChild(new AbstractNumUnitDecorator(elem));
    elems := object_.Nums();
    for _,elem in elems do
        {self.}AppendChild(new NumUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function NumUnitDecorator.Create(_obj: Num);
begin
    class(Num).Create();
    object_ := _obj;
    {self.}Convert();
end;

function NumUnitDecorator.GetObject();
begin
    return object_;
end;

function NumUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrNumId) then
        {self.}NumId := object_.XmlAttrNumId.Value;
    if not ifnil(object_.XmlChildAbstractNumId) then
        {self.}XmlChildAbstractNumId := new PureWValUnitDecorator(object_.XmlChildAbstractNumId);
    tslassigning := tslassigning_backup;
end;

function AbstractNumUnitDecorator.Create(_obj: AbstractNum);
begin
    class(AbstractNum).Create();
    object_ := _obj;
    {self.}Convert();
end;

function AbstractNumUnitDecorator.GetObject();
begin
    return object_;
end;

function AbstractNumUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrAbstractNumId) then
        {self.}AbstractNumId := object_.XmlAttrAbstractNumId.Value;
    if not ifnil(object_.XmlAttrRestartNumberingAfterBreak) then
        {self.}RestartNumberingAfterBreak := object_.XmlAttrRestartNumberingAfterBreak.Value;
    if not ifnil(object_.XmlChildNsid) then
        {self.}XmlChildNsid := new PureWValUnitDecorator(object_.XmlChildNsid);
    if not ifnil(object_.XmlChildMultiLevelType) then
        {self.}XmlChildMultiLevelType := new PureWValUnitDecorator(object_.XmlChildMultiLevelType);
    if not ifnil(object_.XmlChildTmpl) then
        {self.}XmlChildTmpl := new PureWValUnitDecorator(object_.XmlChildTmpl);
    elems := object_.Lvls();
    for _,elem in elems do
        {self.}AppendChild(new LvlUnitDecorator(elem));
    tslassigning := tslassigning_backup;
end;

function LvlUnitDecorator.Create(_obj: Lvl);
begin
    class(Lvl).Create();
    object_ := _obj;
    {self.}Convert();
end;

function LvlUnitDecorator.GetObject();
begin
    return object_;
end;

function LvlUnitDecorator.Convert();
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    if not ifnil(object_.XmlAttrIlvl) then
        {self.}Ilvl := object_.XmlAttrIlvl.Value;
    if not ifnil(object_.XmlAttrTentative) then
        {self.}Tentative := object_.XmlAttrTentative.Value;
    if not ifnil(object_.XmlChildStart) then
        {self.}XmlChildStart := new PureWValUnitDecorator(object_.XmlChildStart);
    if not ifnil(object_.XmlChildNumFmt) then
        {self.}XmlChildNumFmt := new PureWValUnitDecorator(object_.XmlChildNumFmt);
    if not ifnil(object_.XmlChildPStyle) then
        {self.}XmlChildPStyle := new PureWValUnitDecorator(object_.XmlChildPStyle);
    if not ifnil(object_.XmlChildSuff) then
        {self.}XmlChildSuff := new PureWValUnitDecorator(object_.XmlChildSuff);
    if not ifnil(object_.XmlChildLvlText) then
        {self.}XmlChildLvlText := new PureWValUnitDecorator(object_.XmlChildLvlText);
    if not ifnil(object_.XmlChildLvlJc) then
        {self.}XmlChildLvlJc := new PureWValUnitDecorator(object_.XmlChildLvlJc);
    if not ifnil(object_.XmlChildPPr) then
        {self.}XmlChildPPr := new PPrUnitDecorator(object_.XmlChildPPr);
    if not ifnil(object_.XmlChildRPr) then
        {self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
    tslassigning := tslassigning_backup;
end;

end.