unit DocxML;
interface
uses TSSafeUnitConverter, SharedML, VML, DrawingML;

type Properties = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Properties);override;
    function ConvertToPoint();override;

public

    // pcdata property
    property Template read ReadXmlChildTemplate write WriteXmlChildTemplate;
    property TotalTime read ReadXmlChildTotalTime write WriteXmlChildTotalTime;
    property Pages read ReadXmlChildPages write WriteXmlChildPages;
    property Words read ReadXmlChildWords write WriteXmlChildWords;
    property Characters read ReadXmlChildCharacters write WriteXmlChildCharacters;
    property Application read ReadXmlChildApplication write WriteXmlChildApplication;
    property DocSecurity read ReadXmlChildDocSecurity write WriteXmlChildDocSecurity;
    property Lines read ReadXmlChildLines write WriteXmlChildLines;
    property Paragraphs read ReadXmlChildParagraphs write WriteXmlChildParagraphs;
    property ScaleCrop read ReadXmlChildScaleCrop write WriteXmlChildScaleCrop;
    property Company read ReadXmlChildCompany write WriteXmlChildCompany;
    property LinksUpToDate read ReadXmlChildLinksUpToDate write WriteXmlChildLinksUpToDate;
    property CharactersWithSpaces read ReadXmlChildCharactersWithSpaces write WriteXmlChildCharactersWithSpaces;
    property SharedDoc read ReadXmlChildSharedDoc write WriteXmlChildSharedDoc;
    property HyperlinksChanged read ReadXmlChildHyperlinksChanged write WriteXmlChildHyperlinksChanged;
    property AppVersion read ReadXmlChildAppVersion write WriteXmlChildAppVersion;
    function ReadXmlChildTemplate();
    function WriteXmlChildTemplate(_value: nil_or_OpenXmlTextElement);
    function ReadXmlChildTotalTime();
    function WriteXmlChildTotalTime(_value: nil_or_OpenXmlTextElement);
    function ReadXmlChildPages();
    function WriteXmlChildPages(_value: nil_or_OpenXmlTextElement);
    function ReadXmlChildWords();
    function WriteXmlChildWords(_value: nil_or_OpenXmlTextElement);
    function ReadXmlChildCharacters();
    function WriteXmlChildCharacters(_value: nil_or_OpenXmlTextElement);
    function ReadXmlChildApplication();
    function WriteXmlChildApplication(_value: nil_or_OpenXmlTextElement);
    function ReadXmlChildDocSecurity();
    function WriteXmlChildDocSecurity(_value: nil_or_OpenXmlTextElement);
    function ReadXmlChildLines();
    function WriteXmlChildLines(_value: nil_or_OpenXmlTextElement);
    function ReadXmlChildParagraphs();
    function WriteXmlChildParagraphs(_value: nil_or_OpenXmlTextElement);
    function ReadXmlChildScaleCrop();
    function WriteXmlChildScaleCrop(_value: nil_or_OpenXmlTextElement);
    function ReadXmlChildCompany();
    function WriteXmlChildCompany(_value: nil_or_OpenXmlTextElement);
    function ReadXmlChildLinksUpToDate();
    function WriteXmlChildLinksUpToDate(_value: nil_or_OpenXmlTextElement);
    function ReadXmlChildCharactersWithSpaces();
    function WriteXmlChildCharactersWithSpaces(_value: nil_or_OpenXmlTextElement);
    function ReadXmlChildSharedDoc();
    function WriteXmlChildSharedDoc(_value: nil_or_OpenXmlTextElement);
    function ReadXmlChildHyperlinksChanged();
    function WriteXmlChildHyperlinksChanged(_value: nil_or_OpenXmlTextElement);
    function ReadXmlChildAppVersion();
    function WriteXmlChildAppVersion(_value: nil_or_OpenXmlTextElement);

public
    // Children
    XmlChildTemplate: OpenXmlTextElement;
    XmlChildTotalTime: OpenXmlTextElement;
    XmlChildPages: OpenXmlTextElement;
    XmlChildWords: OpenXmlTextElement;
    XmlChildCharacters: OpenXmlTextElement;
    XmlChildApplication: OpenXmlTextElement;
    XmlChildDocSecurity: OpenXmlTextElement;
    XmlChildLines: OpenXmlTextElement;
    XmlChildParagraphs: OpenXmlTextElement;
    XmlChildScaleCrop: OpenXmlTextElement;
    XmlChildCompany: OpenXmlTextElement;
    XmlChildLinksUpToDate: OpenXmlTextElement;
    XmlChildCharactersWithSpaces: OpenXmlTextElement;
    XmlChildSharedDoc: OpenXmlTextElement;
    XmlChildHyperlinksChanged: OpenXmlTextElement;
    XmlChildAppVersion: OpenXmlTextElement;
end;

type Document = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Document);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Ignorable read ReadXmlAttrIgnorable write WriteXmlAttrIgnorable;
    function ReadXmlAttrIgnorable();
    function WriteXmlAttrIgnorable(_value: any);

    // normal property
    property Body read ReadXmlChildBody write WriteXmlChildBody;
    function ReadXmlChildBody(): Body;
    function WriteXmlChildBody(_p1: any; _p2: any);

public
    // Attributes
    XmlAttrIgnorable: OpenXmlAttribute;

    // Children
    XmlChildBody: Body;
end;

type Body = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Body);override;
    function ConvertToPoint();override;

public

    // normal property
    property SectPr read ReadXmlChildSectPr write WriteXmlChildSectPr;
    function ReadXmlChildSectPr(): SectPr;
    function WriteXmlChildSectPr(_p1: any; _p2: any);

    // multi property
    property Ps read ReadPs write WritePs;
    property Tbls read ReadTbls write WriteTbls;
    property Sdts read ReadSdts write WriteSdts;
    function ReadPs(_index: integer);
    function WritePs(_index: integer; _value: nil_OR_P);
    function ReadTbls(_index: integer);
    function WriteTbls(_index: integer; _value: nil_OR_Tbl);
    function ReadSdts(_index: integer);
    function WriteSdts(_index: integer; _value: nil_OR_Sdt);
    function AddP(): P;
    function AddTbl(): Tbl;
    function AddSdt(): Sdt;
    function AppendP(): P;
    function AppendTbl(): Tbl;
    function AppendSdt(): Sdt;

public
    // Children
    XmlChildSectPr: SectPr;
end;

type P = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: P);override;
    function ConvertToPoint();override;

public
    // attributes property
    property ParaId read ReadXmlAttrParaId write WriteXmlAttrParaId;
    property TextId read ReadXmlAttrTextId write WriteXmlAttrTextId;
    property RsidR read ReadXmlAttrRsidR write WriteXmlAttrRsidR;
    property RsidRPr read ReadXmlAttrRsidRPr write WriteXmlAttrRsidRPr;
    property RsidRDefault read ReadXmlAttrRsidRDefault write WriteXmlAttrRsidRDefault;
    property RsidP read ReadXmlAttrRsidP write WriteXmlAttrRsidP;
    function ReadXmlAttrParaId();
    function WriteXmlAttrParaId(_value: any);
    function ReadXmlAttrTextId();
    function WriteXmlAttrTextId(_value: any);
    function ReadXmlAttrRsidR();
    function WriteXmlAttrRsidR(_value: any);
    function ReadXmlAttrRsidRPr();
    function WriteXmlAttrRsidRPr(_value: any);
    function ReadXmlAttrRsidRDefault();
    function WriteXmlAttrRsidRDefault(_value: any);
    function ReadXmlAttrRsidP();
    function WriteXmlAttrRsidP(_value: any);

    // normal property
    property PPr read ReadXmlChildPPr write WriteXmlChildPPr;
    property OMathPara read ReadXmlChildOMathPara write WriteXmlChildOMathPara;
    property OMath read ReadXmlChildOMath write WriteXmlChildOMath;
    property Ins read ReadXmlChildIns write WriteXmlChildIns;
    property Del read ReadXmlChildDel write WriteXmlChildDel;
    function ReadXmlChildPPr(): PPr;
    function WriteXmlChildPPr(_p1: any; _p2: any);
    function ReadXmlChildOMathPara(): OMathPara;
    function WriteXmlChildOMathPara(_p1: any; _p2: any);
    function ReadXmlChildOMath(): OMath;
    function WriteXmlChildOMath(_p1: any; _p2: any);
    function ReadXmlChildIns(): Ins;
    function WriteXmlChildIns(_p1: any; _p2: any);
    function ReadXmlChildDel(): Del;
    function WriteXmlChildDel(_p1: any; _p2: any);

    // multi property
    property Sdts read ReadSdts write WriteSdts;
    property Rs read ReadRs write WriteRs;
    property CommentRangeStarts read ReadCommentRangeStarts write WriteCommentRangeStarts;
    property CommentRangeEnds read ReadCommentRangeEnds write WriteCommentRangeEnds;
    property BookmarkStarts read ReadBookmarkStarts write WriteBookmarkStarts;
    property BookmarkEnds read ReadBookmarkEnds write WriteBookmarkEnds;
    property Hyperlinks read ReadHyperlinks write WriteHyperlinks;
    property FldSimples read ReadFldSimples write WriteFldSimples;
    function ReadSdts(_index: integer);
    function WriteSdts(_index: integer; _value: nil_OR_Sdt);
    function ReadRs(_index: integer);
    function WriteRs(_index: integer; _value: nil_OR_R);
    function ReadCommentRangeStarts(_index: integer);
    function WriteCommentRangeStarts(_index: integer; _value: nil_OR_CommentRange);
    function ReadCommentRangeEnds(_index: integer);
    function WriteCommentRangeEnds(_index: integer; _value: nil_OR_CommentRange);
    function ReadBookmarkStarts(_index: integer);
    function WriteBookmarkStarts(_index: integer; _value: nil_OR_Bookmark);
    function ReadBookmarkEnds(_index: integer);
    function WriteBookmarkEnds(_index: integer; _value: nil_OR_Bookmark);
    function ReadHyperlinks(_index: integer);
    function WriteHyperlinks(_index: integer; _value: nil_OR_HyperLink);
    function ReadFldSimples(_index: integer);
    function WriteFldSimples(_index: integer; _value: nil_OR_FldSimple);
    function AddSdt(): Sdt;
    function AddR(): R;
    function AddCommentRangeStart(): CommentRange;
    function AddCommentRangeEnd(): CommentRange;
    function AddBookmarkStart(): Bookmark;
    function AddBookmarkEnd(): Bookmark;
    function AddHyperLink(): HyperLink;
    function AddFldSimple(): FldSimple;
    function AppendSdt(): Sdt;
    function AppendR(): R;
    function AppendCommentRangeStart(): CommentRange;
    function AppendCommentRangeEnd(): CommentRange;
    function AppendBookmarkStart(): Bookmark;
    function AppendBookmarkEnd(): Bookmark;
    function AppendHyperLink(): HyperLink;
    function AppendFldSimple(): FldSimple;

public
    // Attributes
    XmlAttrParaId: OpenXmlAttribute;
    XmlAttrTextId: OpenXmlAttribute;
    XmlAttrRsidR: OpenXmlAttribute;
    XmlAttrRsidRPr: OpenXmlAttribute;
    XmlAttrRsidRDefault: OpenXmlAttribute;
    XmlAttrRsidP: OpenXmlAttribute;

    // Children
    XmlChildPPr: PPr;
    XmlChildOMathPara: OMathPara;
    XmlChildOMath: OMath;
    XmlChildIns: Ins;
    XmlChildDel: Del;
end;

type FldSimple = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: FldSimple);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Dirty read ReadXmlAttrDirty write WriteXmlAttrDirty;
    property FldLock read ReadXmlAttrFldLock write WriteXmlAttrFldLock;
    property Instr read ReadXmlAttrInstr write WriteXmlAttrInstr;
    function ReadXmlAttrDirty();
    function WriteXmlAttrDirty(_value: any);
    function ReadXmlAttrFldLock();
    function WriteXmlAttrFldLock(_value: any);
    function ReadXmlAttrInstr();
    function WriteXmlAttrInstr(_value: any);

    // multi property
    property Rs read ReadRs write WriteRs;
    function ReadRs(_index: integer);
    function WriteRs(_index: integer; _value: nil_OR_R);
    function AddR(): R;
    function AppendR(): R;

public
    // Attributes
    XmlAttrDirty: OpenXmlAttribute;
    XmlAttrFldLock: OpenXmlAttribute;
    XmlAttrInstr: OpenXmlAttribute;

    // Children
end;

type CommentRange = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: CommentRange);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Id read ReadXmlAttrId write WriteXmlAttrId;
    function ReadXmlAttrId();
    function WriteXmlAttrId(_value: any);

public
    // Attributes
    XmlAttrId: OpenXmlAttribute;

end;

type HyperLink = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: HyperLink);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Anchor read ReadXmlAttrAnchor write WriteXmlAttrAnchor;
    property Id read ReadXmlAttrId write WriteXmlAttrId;
    property History read ReadXmlAttrHistory write WriteXmlAttrHistory;
    function ReadXmlAttrAnchor();
    function WriteXmlAttrAnchor(_value: any);
    function ReadXmlAttrId();
    function WriteXmlAttrId(_value: any);
    function ReadXmlAttrHistory();
    function WriteXmlAttrHistory(_value: any);

    // multi property
    property Rs read ReadRs write WriteRs;
    function ReadRs(_index: integer);
    function WriteRs(_index: integer; _value: nil_OR_R);
    function AddR(): R;
    function AppendR(): R;

public
    // Attributes
    XmlAttrAnchor: OpenXmlAttribute;
    XmlAttrId: OpenXmlAttribute;
    XmlAttrHistory: OpenXmlAttribute;

    // Children
end;

type Bookmark = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Bookmark);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Name read ReadXmlAttrName write WriteXmlAttrName;
    property Id read ReadXmlAttrId write WriteXmlAttrId;
    function ReadXmlAttrName();
    function WriteXmlAttrName(_value: any);
    function ReadXmlAttrId();
    function WriteXmlAttrId(_value: any);

public
    // Attributes
    XmlAttrName: OpenXmlAttribute;
    XmlAttrId: OpenXmlAttribute;

end;

type PPr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: PPr);override;
    function ConvertToPoint();override;

public

    // simple_type property
    property Bidi read ReadXmlChildBidi write WriteXmlChildBidi;
    property WidowControl read ReadXmlChildWidowControl write WriteXmlChildWidowControl;
    property SnapToGrid read ReadXmlChildSnapToGrid write WriteXmlChildSnapToGrid;
    property KeepNext read ReadXmlChildKeepNext write WriteXmlChildKeepNext;
    property KeepLines read ReadXmlChildKeepLines write WriteXmlChildKeepLines;
    property MirrorIndents read ReadXmlChildMirrorIndents write WriteXmlChildMirrorIndents;
    property PageBreakBefore read ReadXmlChildPageBreakBefore write WriteXmlChildPageBreakBefore;
    property SuppressAutoHyphens read ReadXmlChildSuppressAutoHyphens write WriteXmlChildSuppressAutoHyphens;
    property SuppressLineNumbers read ReadXmlChildSuppressLineNumbers write WriteXmlChildSuppressLineNumbers;
    property SuppressOverlap read ReadXmlChildSuppressOverlap write WriteXmlChildSuppressOverlap;
    property ContextualSpacing read ReadXmlChildContextualSpacing write WriteXmlChildContextualSpacing;
    function ReadXmlChildBidi(): OpenXmlSimpleType;
    function WriteXmlChildBidi(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildWidowControl(): OpenXmlSimpleType;
    function WriteXmlChildWidowControl(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildSnapToGrid(): OpenXmlSimpleType;
    function WriteXmlChildSnapToGrid(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildKeepNext(): OpenXmlSimpleType;
    function WriteXmlChildKeepNext(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildKeepLines(): OpenXmlSimpleType;
    function WriteXmlChildKeepLines(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildMirrorIndents(): OpenXmlSimpleType;
    function WriteXmlChildMirrorIndents(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildPageBreakBefore(): OpenXmlSimpleType;
    function WriteXmlChildPageBreakBefore(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildSuppressAutoHyphens(): OpenXmlSimpleType;
    function WriteXmlChildSuppressAutoHyphens(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildSuppressLineNumbers(): OpenXmlSimpleType;
    function WriteXmlChildSuppressLineNumbers(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildSuppressOverlap(): OpenXmlSimpleType;
    function WriteXmlChildSuppressOverlap(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildContextualSpacing(): OpenXmlSimpleType;
    function WriteXmlChildContextualSpacing(_value: nil_or_OpenXmlSimpleType);

    // normal property
    property SectPr read ReadXmlChildSectPr write WriteXmlChildSectPr;
    property Tabs read ReadXmlChildTabs write WriteXmlChildTabs;
    property PStyle read ReadXmlChildPStyle write WriteXmlChildPStyle;
    property NumPr read ReadXmlChildNumPr write WriteXmlChildNumPr;
    property Jc read ReadXmlChildJc write WriteXmlChildJc;
    property Ind read ReadXmlChildInd write WriteXmlChildInd;
    property Kinsoku read ReadXmlChildKinsoku write WriteXmlChildKinsoku;
    property OverflowPunct read ReadXmlChildOverflowPunct write WriteXmlChildOverflowPunct;
    property AdjustRightInd read ReadXmlChildAdjustRightInd write WriteXmlChildAdjustRightInd;
    property Spacing read ReadXmlChildSpacing write WriteXmlChildSpacing;
    property OutlineLvl read ReadXmlChildOutlineLvl write WriteXmlChildOutlineLvl;
    property AutoSpaceDE read ReadXmlChildAutoSpaceDE write WriteXmlChildAutoSpaceDE;
    property AutoSpaceDN read ReadXmlChildAutoSpaceDN write WriteXmlChildAutoSpaceDN;
    property RPr read ReadXmlChildRPr write WriteXmlChildRPr;
    property PBdr read ReadXmlChildPBdr write WriteXmlChildPBdr;
    property Shd read ReadXmlChildShd write WriteXmlChildShd;
    property WordWrap read ReadXmlChildWordWrap write WriteXmlChildWordWrap;
    property DivId read ReadXmlChildDivId write WriteXmlChildDivId;
    property CnfStyle read ReadXmlChildCnfStyle write WriteXmlChildCnfStyle;
    property FramePr read ReadXmlChildFramePr write WriteXmlChildFramePr;
    property TextboxTightWrap read ReadXmlChildTextboxTightWrap write WriteXmlChildTextboxTightWrap;
    property TopLinePunct read ReadXmlChildTopLinePunct write WriteXmlChildTopLinePunct;
    property TextAlignment read ReadXmlChildTextAlignment write WriteXmlChildTextAlignment;
    property TextDirection read ReadXmlChildTextDirection write WriteXmlChildTextDirection;
    property Collapsed read ReadXmlChildCollapsed write WriteXmlChildCollapsed;
    function ReadXmlChildSectPr(): SectPr;
    function WriteXmlChildSectPr(_p1: any; _p2: any);
    function ReadXmlChildTabs(): Tabs;
    function WriteXmlChildTabs(_p1: any; _p2: any);
    function ReadXmlChildPStyle(): PureWVal;
    function WriteXmlChildPStyle(_p1: any; _p2: any);
    function ReadXmlChildNumPr(): NumPr;
    function WriteXmlChildNumPr(_p1: any; _p2: any);
    function ReadXmlChildJc(): PureWVal;
    function WriteXmlChildJc(_p1: any; _p2: any);
    function ReadXmlChildInd(): Ind;
    function WriteXmlChildInd(_p1: any; _p2: any);
    function ReadXmlChildKinsoku(): PureWVal;
    function WriteXmlChildKinsoku(_p1: any; _p2: any);
    function ReadXmlChildOverflowPunct(): PureWVal;
    function WriteXmlChildOverflowPunct(_p1: any; _p2: any);
    function ReadXmlChildAdjustRightInd(): PureWVal;
    function WriteXmlChildAdjustRightInd(_p1: any; _p2: any);
    function ReadXmlChildSpacing(): Spacing;
    function WriteXmlChildSpacing(_p1: any; _p2: any);
    function ReadXmlChildOutlineLvl(): PureWVal;
    function WriteXmlChildOutlineLvl(_p1: any; _p2: any);
    function ReadXmlChildAutoSpaceDE(): PureWVal;
    function WriteXmlChildAutoSpaceDE(_p1: any; _p2: any);
    function ReadXmlChildAutoSpaceDN(): PureWVal;
    function WriteXmlChildAutoSpaceDN(_p1: any; _p2: any);
    function ReadXmlChildRPr(): RPr;
    function WriteXmlChildRPr(_p1: any; _p2: any);
    function ReadXmlChildPBdr(): PBdr;
    function WriteXmlChildPBdr(_p1: any; _p2: any);
    function ReadXmlChildShd(): Shd;
    function WriteXmlChildShd(_p1: any; _p2: any);
    function ReadXmlChildWordWrap(): PureWVal;
    function WriteXmlChildWordWrap(_p1: any; _p2: any);
    function ReadXmlChildDivId(): PureWVal;
    function WriteXmlChildDivId(_p1: any; _p2: any);
    function ReadXmlChildCnfStyle(): PureWVal;
    function WriteXmlChildCnfStyle(_p1: any; _p2: any);
    function ReadXmlChildFramePr(): FramePr;
    function WriteXmlChildFramePr(_p1: any; _p2: any);
    function ReadXmlChildTextboxTightWrap(): PureWVal;
    function WriteXmlChildTextboxTightWrap(_p1: any; _p2: any);
    function ReadXmlChildTopLinePunct(): PureWVal;
    function WriteXmlChildTopLinePunct(_p1: any; _p2: any);
    function ReadXmlChildTextAlignment(): PureWVal;
    function WriteXmlChildTextAlignment(_p1: any; _p2: any);
    function ReadXmlChildTextDirection(): PureWVal;
    function WriteXmlChildTextDirection(_p1: any; _p2: any);
    function ReadXmlChildCollapsed(): PureWVal;
    function WriteXmlChildCollapsed(_p1: any; _p2: any);

public
    // Children
    XmlChildSectPr: SectPr;
    XmlChildTabs: Tabs;
    XmlChildBidi: OpenXmlSimpleType;
    XmlChildWidowControl: OpenXmlSimpleType;
    XmlChildSnapToGrid: OpenXmlSimpleType;
    XmlChildPStyle: PureWVal;
    XmlChildNumPr: NumPr;
    XmlChildJc: PureWVal;
    XmlChildInd: Ind;
    XmlChildKeepNext: OpenXmlSimpleType;
    XmlChildKeepLines: OpenXmlSimpleType;
    XmlChildMirrorIndents: OpenXmlSimpleType;
    XmlChildKinsoku: PureWVal;
    XmlChildPageBreakBefore: OpenXmlSimpleType;
    XmlChildSuppressAutoHyphens: OpenXmlSimpleType;
    XmlChildSuppressLineNumbers: OpenXmlSimpleType;
    XmlChildSuppressOverlap: OpenXmlSimpleType;
    XmlChildOverflowPunct: PureWVal;
    XmlChildAdjustRightInd: PureWVal;
    XmlChildSpacing: Spacing;
    XmlChildOutlineLvl: PureWVal;
    XmlChildAutoSpaceDE: PureWVal;
    XmlChildAutoSpaceDN: PureWVal;
    XmlChildRPr: RPr;
    XmlChildPBdr: PBdr;
    XmlChildContextualSpacing: OpenXmlSimpleType;
    XmlChildShd: Shd;
    XmlChildWordWrap: PureWVal;
    XmlChildDivId: PureWVal;
    XmlChildCnfStyle: PureWVal;
    XmlChildFramePr: FramePr;
    XmlChildTextboxTightWrap: PureWVal;
    XmlChildTopLinePunct: PureWVal;
    XmlChildTextAlignment: PureWVal;
    XmlChildTextDirection: PureWVal;
    XmlChildCollapsed: PureWVal;
end;

type PBdr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: PBdr);override;
    function ConvertToPoint();override;

public

    // normal property
    property Top read ReadXmlChildTop write WriteXmlChildTop;
    property Left read ReadXmlChildLeft write WriteXmlChildLeft;
    property Right read ReadXmlChildRight write WriteXmlChildRight;
    property Bottom read ReadXmlChildBottom write WriteXmlChildBottom;
    property Between read ReadXmlChildBetween write WriteXmlChildBetween;
    function ReadXmlChildTop(): PBorder;
    function WriteXmlChildTop(_p1: any; _p2: any);
    function ReadXmlChildLeft(): PBorder;
    function WriteXmlChildLeft(_p1: any; _p2: any);
    function ReadXmlChildRight(): PBorder;
    function WriteXmlChildRight(_p1: any; _p2: any);
    function ReadXmlChildBottom(): PBorder;
    function WriteXmlChildBottom(_p1: any; _p2: any);
    function ReadXmlChildBetween(): PBorder;
    function WriteXmlChildBetween(_p1: any; _p2: any);

public
    // Children
    XmlChildTop: PBorder;
    XmlChildLeft: PBorder;
    XmlChildRight: PBorder;
    XmlChildBottom: PBorder;
    XmlChildBetween: PBorder;
end;

type FramePr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: FramePr);override;
    function ConvertToPoint();override;

public
    // attributes property
    property AnchorLock read ReadXmlAttrAnchorLock write WriteXmlAttrAnchorLock;
    property DropCap read ReadXmlAttrDropCap write WriteXmlAttrDropCap;
    property VAnchor read ReadXmlAttrVAnchor write WriteXmlAttrVAnchor;
    property HAnchor read ReadXmlAttrHAnchor write WriteXmlAttrHAnchor;
    property HRule read ReadXmlAttrHRule write WriteXmlAttrHRule;
    property HSpace read ReadXmlAttrHSpace write WriteXmlAttrHSpace;
    property VSpace read ReadXmlAttrVSpace write WriteXmlAttrVSpace;
    property Lines read ReadXmlAttrLines write WriteXmlAttrLines;
    property Wrap read ReadXmlAttrWrap write WriteXmlAttrWrap;
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    property W read ReadXmlAttrW write WriteXmlAttrW;
    property H read ReadXmlAttrH write WriteXmlAttrH;
    property X read ReadXmlAttrX write WriteXmlAttrX;
    property Y read ReadXmlAttrY write WriteXmlAttrY;
    property XAlign read ReadXmlAttrXAlign write WriteXmlAttrXAlign;
    property YAlign read ReadXmlAttrYAlign write WriteXmlAttrYAlign;
    function ReadXmlAttrAnchorLock();
    function WriteXmlAttrAnchorLock(_value: any);
    function ReadXmlAttrDropCap();
    function WriteXmlAttrDropCap(_value: any);
    function ReadXmlAttrVAnchor();
    function WriteXmlAttrVAnchor(_value: any);
    function ReadXmlAttrHAnchor();
    function WriteXmlAttrHAnchor(_value: any);
    function ReadXmlAttrHRule();
    function WriteXmlAttrHRule(_value: any);
    function ReadXmlAttrHSpace();
    function WriteXmlAttrHSpace(_value: any);
    function ReadXmlAttrVSpace();
    function WriteXmlAttrVSpace(_value: any);
    function ReadXmlAttrLines();
    function WriteXmlAttrLines(_value: any);
    function ReadXmlAttrWrap();
    function WriteXmlAttrWrap(_value: any);
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);
    function ReadXmlAttrW();
    function WriteXmlAttrW(_value: any);
    function ReadXmlAttrH();
    function WriteXmlAttrH(_value: any);
    function ReadXmlAttrX();
    function WriteXmlAttrX(_value: any);
    function ReadXmlAttrY();
    function WriteXmlAttrY(_value: any);
    function ReadXmlAttrXAlign();
    function WriteXmlAttrXAlign(_value: any);
    function ReadXmlAttrYAlign();
    function WriteXmlAttrYAlign(_value: any);

public
    // Attributes
    XmlAttrAnchorLock: OpenXmlAttribute;
    XmlAttrDropCap: OpenXmlAttribute;
    XmlAttrVAnchor: OpenXmlAttribute;
    XmlAttrHAnchor: OpenXmlAttribute;
    XmlAttrHRule: OpenXmlAttribute;
    XmlAttrHSpace: OpenXmlAttribute;
    XmlAttrVSpace: OpenXmlAttribute;
    XmlAttrLines: OpenXmlAttribute;
    XmlAttrWrap: OpenXmlAttribute;
    XmlAttrVal: OpenXmlAttribute;
    XmlAttrW: OpenXmlAttribute;
    XmlAttrH: OpenXmlAttribute;
    XmlAttrX: OpenXmlAttribute;
    XmlAttrY: OpenXmlAttribute;
    XmlAttrXAlign: OpenXmlAttribute;
    XmlAttrYAlign: OpenXmlAttribute;

end;

type PBorder = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: PBorder);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    property Color read ReadXmlAttrColor write WriteXmlAttrColor;
    property Space read ReadXmlAttrSpace write WriteXmlAttrSpace;
    property Frame read ReadXmlAttrFrame write WriteXmlAttrFrame;
    property Shadow read ReadXmlAttrShadow write WriteXmlAttrShadow;
    property ThemeColor read ReadXmlAttrThemeColor write WriteXmlAttrThemeColor;
    property ThemeShade read ReadXmlAttrThemeShade write WriteXmlAttrThemeShade;
    property ThemeTint read ReadXmlAttrThemeTint write WriteXmlAttrThemeTint;
    property Sz read ReadXmlAttrSz write WriteXmlAttrSz;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);
    function ReadXmlAttrColor();
    function WriteXmlAttrColor(_value: any);
    function ReadXmlAttrSpace();
    function WriteXmlAttrSpace(_value: any);
    function ReadXmlAttrFrame();
    function WriteXmlAttrFrame(_value: any);
    function ReadXmlAttrShadow();
    function WriteXmlAttrShadow(_value: any);
    function ReadXmlAttrThemeColor();
    function WriteXmlAttrThemeColor(_value: any);
    function ReadXmlAttrThemeShade();
    function WriteXmlAttrThemeShade(_value: any);
    function ReadXmlAttrThemeTint();
    function WriteXmlAttrThemeTint(_value: any);
    function ReadXmlAttrSz();
    function WriteXmlAttrSz(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;
    XmlAttrColor: OpenXmlAttribute;
    XmlAttrSpace: OpenXmlAttribute;
    XmlAttrFrame: OpenXmlAttribute;
    XmlAttrShadow: OpenXmlAttribute;
    XmlAttrThemeColor: OpenXmlAttribute;
    XmlAttrThemeShade: OpenXmlAttribute;
    XmlAttrThemeTint: OpenXmlAttribute;
    XmlAttrSz: OpenXmlAttribute;

end;

type Tabs = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Tabs);override;
    function ConvertToPoint();override;

public

    // multi property
    property Tabs read ReadTabs write WriteTabs;
    function ReadTabs(_index: integer);
    function WriteTabs(_index: integer; _value: nil_OR_Tab);
    function AddTab(): Tab;
    function AppendTab(): Tab;

public
    // Children
end;

type Tab = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Tab);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    property Leader read ReadXmlAttrLeader write WriteXmlAttrLeader;
    property Pos read ReadXmlAttrPos write WriteXmlAttrPos;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);
    function ReadXmlAttrLeader();
    function WriteXmlAttrLeader(_value: any);
    function ReadXmlAttrPos();
    function WriteXmlAttrPos(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;
    XmlAttrLeader: OpenXmlAttribute;
    XmlAttrPos: OpenXmlAttribute;

end;

type NumPr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: NumPr);override;
    function ConvertToPoint();override;

public

    // normal property
    property Ilvl read ReadXmlChildIlvl write WriteXmlChildIlvl;
    property NumId read ReadXmlChildNumId write WriteXmlChildNumId;
    function ReadXmlChildIlvl(): PureWVal;
    function WriteXmlChildIlvl(_p1: any; _p2: any);
    function ReadXmlChildNumId(): PureWVal;
    function WriteXmlChildNumId(_p1: any; _p2: any);

public
    // Children
    XmlChildIlvl: PureWVal;
    XmlChildNumId: PureWVal;
end;

type Ind = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Ind);override;
    function ConvertToPoint();override;

public
    // attributes property
    property FirstLineChars read ReadXmlAttrFirstLineChars write WriteXmlAttrFirstLineChars;
    property FirstLine read ReadXmlAttrFirstLine write WriteXmlAttrFirstLine;
    property RightChars read ReadXmlAttrRightChars write WriteXmlAttrRightChars;
    property Right read ReadXmlAttrRight write WriteXmlAttrRight;
    property LeftChars read ReadXmlAttrLeftChars write WriteXmlAttrLeftChars;
    property Left read ReadXmlAttrLeft write WriteXmlAttrLeft;
    property Hanging read ReadXmlAttrHanging write WriteXmlAttrHanging;
    property HangingChars read ReadXmlAttrHangingChars write WriteXmlAttrHangingChars;
    function ReadXmlAttrFirstLineChars();
    function WriteXmlAttrFirstLineChars(_value: any);
    function ReadXmlAttrFirstLine();
    function WriteXmlAttrFirstLine(_value: any);
    function ReadXmlAttrRightChars();
    function WriteXmlAttrRightChars(_value: any);
    function ReadXmlAttrRight();
    function WriteXmlAttrRight(_value: any);
    function ReadXmlAttrLeftChars();
    function WriteXmlAttrLeftChars(_value: any);
    function ReadXmlAttrLeft();
    function WriteXmlAttrLeft(_value: any);
    function ReadXmlAttrHanging();
    function WriteXmlAttrHanging(_value: any);
    function ReadXmlAttrHangingChars();
    function WriteXmlAttrHangingChars(_value: any);

public
    // Attributes
    XmlAttrFirstLineChars: OpenXmlAttribute;
    XmlAttrFirstLine: OpenXmlAttribute;
    XmlAttrRightChars: OpenXmlAttribute;
    XmlAttrRight: OpenXmlAttribute;
    XmlAttrLeftChars: OpenXmlAttribute;
    XmlAttrLeft: OpenXmlAttribute;
    XmlAttrHanging: OpenXmlAttribute;
    XmlAttrHangingChars: OpenXmlAttribute;

end;

type Spacing = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Spacing);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Before read ReadXmlAttrBefore write WriteXmlAttrBefore;
    property BeforeLines read ReadXmlAttrBeforeLines write WriteXmlAttrBeforeLines;
    property BeforeAutospacing read ReadXmlAttrBeforeAutospacing write WriteXmlAttrBeforeAutospacing;
    property After read ReadXmlAttrAfter write WriteXmlAttrAfter;
    property AfterLines read ReadXmlAttrAfterLines write WriteXmlAttrAfterLines;
    property AfterAutospacing read ReadXmlAttrAfterAutospacing write WriteXmlAttrAfterAutospacing;
    property Line read ReadXmlAttrLine write WriteXmlAttrLine;
    property LineRule read ReadXmlAttrLineRule write WriteXmlAttrLineRule;
    function ReadXmlAttrBefore();
    function WriteXmlAttrBefore(_value: any);
    function ReadXmlAttrBeforeLines();
    function WriteXmlAttrBeforeLines(_value: any);
    function ReadXmlAttrBeforeAutospacing();
    function WriteXmlAttrBeforeAutospacing(_value: any);
    function ReadXmlAttrAfter();
    function WriteXmlAttrAfter(_value: any);
    function ReadXmlAttrAfterLines();
    function WriteXmlAttrAfterLines(_value: any);
    function ReadXmlAttrAfterAutospacing();
    function WriteXmlAttrAfterAutospacing(_value: any);
    function ReadXmlAttrLine();
    function WriteXmlAttrLine(_value: any);
    function ReadXmlAttrLineRule();
    function WriteXmlAttrLineRule(_value: any);

public
    // Attributes
    XmlAttrBefore: OpenXmlAttribute;
    XmlAttrBeforeLines: OpenXmlAttribute;
    XmlAttrBeforeAutospacing: OpenXmlAttribute;
    XmlAttrAfter: OpenXmlAttribute;
    XmlAttrAfterLines: OpenXmlAttribute;
    XmlAttrAfterAutospacing: OpenXmlAttribute;
    XmlAttrLine: OpenXmlAttribute;
    XmlAttrLineRule: OpenXmlAttribute;

end;

type RPr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: RPr);override;
    function ConvertToPoint();override;

public

    // simple_type property
    property I read ReadXmlChildI write WriteXmlChildI;
    property ICs read ReadXmlChildICs write WriteXmlChildICs;
    property B read ReadXmlChildB write WriteXmlChildB;
    property BCs read ReadXmlChildBCs write WriteXmlChildBCs;
    property Strike read ReadXmlChildStrike write WriteXmlChildStrike;
    property Cs read ReadXmlChildCs write WriteXmlChildCs;
    property U read ReadXmlChildU write WriteXmlChildU;
    property OMath read ReadXmlChildOMath write WriteXmlChildOMath;
    property Shadow read ReadXmlChildShadow write WriteXmlChildShadow;
    property SpecVanish read ReadXmlChildSpecVanish write WriteXmlChildSpecVanish;
    property Vanish read ReadXmlChildVanish write WriteXmlChildVanish;
    function ReadXmlChildI(): OpenXmlSimpleType;
    function WriteXmlChildI(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildICs(): OpenXmlSimpleType;
    function WriteXmlChildICs(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildB(): OpenXmlSimpleType;
    function WriteXmlChildB(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildBCs(): OpenXmlSimpleType;
    function WriteXmlChildBCs(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildStrike(): OpenXmlSimpleType;
    function WriteXmlChildStrike(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildCs(): OpenXmlSimpleType;
    function WriteXmlChildCs(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildU(): OpenXmlSimpleType;
    function WriteXmlChildU(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildOMath(): OpenXmlSimpleType;
    function WriteXmlChildOMath(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildShadow(): OpenXmlSimpleType;
    function WriteXmlChildShadow(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildSpecVanish(): OpenXmlSimpleType;
    function WriteXmlChildSpecVanish(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildVanish(): OpenXmlSimpleType;
    function WriteXmlChildVanish(_value: nil_or_OpenXmlSimpleType);

    // normal property
    property NoProof read ReadXmlChildNoProof write WriteXmlChildNoProof;
    property Outline read ReadXmlChildOutline write WriteXmlChildOutline;
    property Position read ReadXmlChildPosition write WriteXmlChildPosition;
    property WebHidden read ReadXmlChildWebHidden write WriteXmlChildWebHidden;
    property RStyle read ReadXmlChildRStyle write WriteXmlChildRStyle;
    property Ins read ReadXmlChildIns write WriteXmlChildIns;
    property RFonts read ReadXmlChildRFonts write WriteXmlChildRFonts;
    property Kern read ReadXmlChildKern write WriteXmlChildKern;
    property Bdr read ReadXmlChildBdr write WriteXmlChildBdr;
    property Caps read ReadXmlChildCaps write WriteXmlChildCaps;
    property Del read ReadXmlChildDel write WriteXmlChildDel;
    property DStrike read ReadXmlChildDStrike write WriteXmlChildDStrike;
    property Effect read ReadXmlChildEffect write WriteXmlChildEffect;
    property Em read ReadXmlChildEm write WriteXmlChildEm;
    property Emboss read ReadXmlChildEmboss write WriteXmlChildEmboss;
    property FitText read ReadXmlChildFitText write WriteXmlChildFitText;
    property Highlight read ReadXmlChildHighlight write WriteXmlChildHighlight;
    property Color read ReadXmlChildColor write WriteXmlChildColor;
    property EastAsianLayout read ReadXmlChildEastAsianLayout write WriteXmlChildEastAsianLayout;
    property Sz read ReadXmlChildSz write WriteXmlChildSz;
    property SzCs read ReadXmlChildSzCs write WriteXmlChildSzCs;
    property Lang read ReadXmlChildLang write WriteXmlChildLang;
    property Imprint read ReadXmlChildImprint write WriteXmlChildImprint;
    property VertAlign read ReadXmlChildVertAlign write WriteXmlChildVertAlign;
    property Ligatures read ReadXmlChildLigatures write WriteXmlChildLigatures;
    property Rtl read ReadXmlChildRtl write WriteXmlChildRtl;
    property Shd read ReadXmlChildShd write WriteXmlChildShd;
    property SmallCaps read ReadXmlChildSmallCaps write WriteXmlChildSmallCaps;
    property W read ReadXmlChildW write WriteXmlChildW;
    function ReadXmlChildNoProof(): PureVal;
    function WriteXmlChildNoProof(_p1: any; _p2: any);
    function ReadXmlChildOutline(): PureVal;
    function WriteXmlChildOutline(_p1: any; _p2: any);
    function ReadXmlChildPosition(): PureVal;
    function WriteXmlChildPosition(_p1: any; _p2: any);
    function ReadXmlChildWebHidden(): PureWVal;
    function WriteXmlChildWebHidden(_p1: any; _p2: any);
    function ReadXmlChildRStyle(): PureWVal;
    function WriteXmlChildRStyle(_p1: any; _p2: any);
    function ReadXmlChildIns(): Ins;
    function WriteXmlChildIns(_p1: any; _p2: any);
    function ReadXmlChildRFonts(): RFonts;
    function WriteXmlChildRFonts(_p1: any; _p2: any);
    function ReadXmlChildKern(): PureWVal;
    function WriteXmlChildKern(_p1: any; _p2: any);
    function ReadXmlChildBdr(): Bdr;
    function WriteXmlChildBdr(_p1: any; _p2: any);
    function ReadXmlChildCaps(): PureWVal;
    function WriteXmlChildCaps(_p1: any; _p2: any);
    function ReadXmlChildDel(): Del;
    function WriteXmlChildDel(_p1: any; _p2: any);
    function ReadXmlChildDStrike(): PureWVal;
    function WriteXmlChildDStrike(_p1: any; _p2: any);
    function ReadXmlChildEffect(): PureWVal;
    function WriteXmlChildEffect(_p1: any; _p2: any);
    function ReadXmlChildEm(): PureWVal;
    function WriteXmlChildEm(_p1: any; _p2: any);
    function ReadXmlChildEmboss(): PureWVal;
    function WriteXmlChildEmboss(_p1: any; _p2: any);
    function ReadXmlChildFitText(): FitText;
    function WriteXmlChildFitText(_p1: any; _p2: any);
    function ReadXmlChildHighlight(): Highlight;
    function WriteXmlChildHighlight(_p1: any; _p2: any);
    function ReadXmlChildColor(): Color;
    function WriteXmlChildColor(_p1: any; _p2: any);
    function ReadXmlChildEastAsianLayout(): EastAsianLayout;
    function WriteXmlChildEastAsianLayout(_p1: any; _p2: any);
    function ReadXmlChildSz(): Sz;
    function WriteXmlChildSz(_p1: any; _p2: any);
    function ReadXmlChildSzCs(): SzCs;
    function WriteXmlChildSzCs(_p1: any; _p2: any);
    function ReadXmlChildLang(): Lang;
    function WriteXmlChildLang(_p1: any; _p2: any);
    function ReadXmlChildImprint(): PureWVal;
    function WriteXmlChildImprint(_p1: any; _p2: any);
    function ReadXmlChildVertAlign(): PureWVal;
    function WriteXmlChildVertAlign(_p1: any; _p2: any);
    function ReadXmlChildLigatures(): PureWVal;
    function WriteXmlChildLigatures(_p1: any; _p2: any);
    function ReadXmlChildRtl(): PureWVal;
    function WriteXmlChildRtl(_p1: any; _p2: any);
    function ReadXmlChildShd(): Shd;
    function WriteXmlChildShd(_p1: any; _p2: any);
    function ReadXmlChildSmallCaps(): PureWVal;
    function WriteXmlChildSmallCaps(_p1: any; _p2: any);
    function ReadXmlChildW(): PureWVal;
    function WriteXmlChildW(_p1: any; _p2: any);

public
    // Children
    XmlChildNoProof: PureVal;
    XmlChildOutline: PureVal;
    XmlChildPosition: PureVal;
    XmlChildWebHidden: PureWVal;
    XmlChildRStyle: PureWVal;
    XmlChildIns: Ins;
    XmlChildRFonts: RFonts;
    XmlChildKern: PureWVal;
    XmlChildI: OpenXmlSimpleType;
    XmlChildICs: OpenXmlSimpleType;
    XmlChildB: OpenXmlSimpleType;
    XmlChildBCs: OpenXmlSimpleType;
    XmlChildBdr: Bdr;
    XmlChildCaps: PureWVal;
    XmlChildDel: Del;
    XmlChildStrike: OpenXmlSimpleType;
    XmlChildDStrike: PureWVal;
    XmlChildEffect: PureWVal;
    XmlChildEm: PureWVal;
    XmlChildEmboss: PureWVal;
    XmlChildFitText: FitText;
    XmlChildHighlight: Highlight;
    XmlChildColor: Color;
    XmlChildEastAsianLayout: EastAsianLayout;
    XmlChildCs: OpenXmlSimpleType;
    XmlChildSz: Sz;
    XmlChildSzCs: SzCs;
    XmlChildU: OpenXmlSimpleType;
    XmlChildLang: Lang;
    XmlChildImprint: PureWVal;
    XmlChildVertAlign: PureWVal;
    XmlChildLigatures: PureWVal;
    XmlChildRtl: PureWVal;
    XmlChildOMath: OpenXmlSimpleType;
    XmlChildShadow: OpenXmlSimpleType;
    XmlChildSpecVanish: OpenXmlSimpleType;
    XmlChildVanish: OpenXmlSimpleType;
    XmlChildShd: Shd;
    XmlChildSmallCaps: PureWVal;
    XmlChildW: PureWVal;
end;

type Shd = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Shd);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    property Color read ReadXmlAttrColor write WriteXmlAttrColor;
    property Fill read ReadXmlAttrFill write WriteXmlAttrFill;
    property ThemeColor read ReadXmlAttrThemeColor write WriteXmlAttrThemeColor;
    property ThemeFill read ReadXmlAttrThemeFill write WriteXmlAttrThemeFill;
    property ThemeFillTint read ReadXmlAttrThemeFillTint write WriteXmlAttrThemeFillTint;
    property ThemeFillShade read ReadXmlAttrThemeFillShade write WriteXmlAttrThemeFillShade;
    property ThemeShade read ReadXmlAttrThemeShade write WriteXmlAttrThemeShade;
    property ThemeTint read ReadXmlAttrThemeTint write WriteXmlAttrThemeTint;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);
    function ReadXmlAttrColor();
    function WriteXmlAttrColor(_value: any);
    function ReadXmlAttrFill();
    function WriteXmlAttrFill(_value: any);
    function ReadXmlAttrThemeColor();
    function WriteXmlAttrThemeColor(_value: any);
    function ReadXmlAttrThemeFill();
    function WriteXmlAttrThemeFill(_value: any);
    function ReadXmlAttrThemeFillTint();
    function WriteXmlAttrThemeFillTint(_value: any);
    function ReadXmlAttrThemeFillShade();
    function WriteXmlAttrThemeFillShade(_value: any);
    function ReadXmlAttrThemeShade();
    function WriteXmlAttrThemeShade(_value: any);
    function ReadXmlAttrThemeTint();
    function WriteXmlAttrThemeTint(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;
    XmlAttrColor: OpenXmlAttribute;
    XmlAttrFill: OpenXmlAttribute;
    XmlAttrThemeColor: OpenXmlAttribute;
    XmlAttrThemeFill: OpenXmlAttribute;
    XmlAttrThemeFillTint: OpenXmlAttribute;
    XmlAttrThemeFillShade: OpenXmlAttribute;
    XmlAttrThemeShade: OpenXmlAttribute;
    XmlAttrThemeTint: OpenXmlAttribute;

end;

type Highlight = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Highlight);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;

end;

type FitText = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: FitText);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Id read ReadXmlAttrId write WriteXmlAttrId;
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    function ReadXmlAttrId();
    function WriteXmlAttrId(_value: any);
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);

public
    // Attributes
    XmlAttrId: OpenXmlAttribute;
    XmlAttrVal: OpenXmlAttribute;

end;

type EastAsianLayout = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: EastAsianLayout);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Combine read ReadXmlAttrCombine write WriteXmlAttrCombine;
    property CombineBrackets read ReadXmlAttrCombineBrackets write WriteXmlAttrCombineBrackets;
    property Id read ReadXmlAttrId write WriteXmlAttrId;
    property Vert read ReadXmlAttrVert write WriteXmlAttrVert;
    property VertCompress read ReadXmlAttrVertCompress write WriteXmlAttrVertCompress;
    function ReadXmlAttrCombine();
    function WriteXmlAttrCombine(_value: any);
    function ReadXmlAttrCombineBrackets();
    function WriteXmlAttrCombineBrackets(_value: any);
    function ReadXmlAttrId();
    function WriteXmlAttrId(_value: any);
    function ReadXmlAttrVert();
    function WriteXmlAttrVert(_value: any);
    function ReadXmlAttrVertCompress();
    function WriteXmlAttrVertCompress(_value: any);

public
    // Attributes
    XmlAttrCombine: OpenXmlAttribute;
    XmlAttrCombineBrackets: OpenXmlAttribute;
    XmlAttrId: OpenXmlAttribute;
    XmlAttrVert: OpenXmlAttribute;
    XmlAttrVertCompress: OpenXmlAttribute;

end;

type Del = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Del);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Author read ReadXmlAttrAuthor write WriteXmlAttrAuthor;
    property Date read ReadXmlAttrDate write WriteXmlAttrDate;
    property Id read ReadXmlAttrId write WriteXmlAttrId;
    property Color read ReadXmlAttrColor write WriteXmlAttrColor;
    property ThemeColor read ReadXmlAttrThemeColor write WriteXmlAttrThemeColor;
    property ThemeShade read ReadXmlAttrThemeShade write WriteXmlAttrThemeShade;
    property ThemeTint read ReadXmlAttrThemeTint write WriteXmlAttrThemeTint;
    property Frame read ReadXmlAttrFrame write WriteXmlAttrFrame;
    property Shadow read ReadXmlAttrShadow write WriteXmlAttrShadow;
    function ReadXmlAttrAuthor();
    function WriteXmlAttrAuthor(_value: any);
    function ReadXmlAttrDate();
    function WriteXmlAttrDate(_value: any);
    function ReadXmlAttrId();
    function WriteXmlAttrId(_value: any);
    function ReadXmlAttrColor();
    function WriteXmlAttrColor(_value: any);
    function ReadXmlAttrThemeColor();
    function WriteXmlAttrThemeColor(_value: any);
    function ReadXmlAttrThemeShade();
    function WriteXmlAttrThemeShade(_value: any);
    function ReadXmlAttrThemeTint();
    function WriteXmlAttrThemeTint(_value: any);
    function ReadXmlAttrFrame();
    function WriteXmlAttrFrame(_value: any);
    function ReadXmlAttrShadow();
    function WriteXmlAttrShadow(_value: any);

public
    // Attributes
    XmlAttrAuthor: OpenXmlAttribute;
    XmlAttrDate: OpenXmlAttribute;
    XmlAttrId: OpenXmlAttribute;
    XmlAttrColor: OpenXmlAttribute;
    XmlAttrThemeColor: OpenXmlAttribute;
    XmlAttrThemeShade: OpenXmlAttribute;
    XmlAttrThemeTint: OpenXmlAttribute;
    XmlAttrFrame: OpenXmlAttribute;
    XmlAttrShadow: OpenXmlAttribute;

end;

type Bdr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Bdr);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    property Sz read ReadXmlAttrSz write WriteXmlAttrSz;
    property Space read ReadXmlAttrSpace write WriteXmlAttrSpace;
    property Color read ReadXmlAttrColor write WriteXmlAttrColor;
    property ThemeColor read ReadXmlAttrThemeColor write WriteXmlAttrThemeColor;
    property ThemeShade read ReadXmlAttrThemeShade write WriteXmlAttrThemeShade;
    property ThemeTint read ReadXmlAttrThemeTint write WriteXmlAttrThemeTint;
    property Frame read ReadXmlAttrFrame write WriteXmlAttrFrame;
    property Shadow read ReadXmlAttrShadow write WriteXmlAttrShadow;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);
    function ReadXmlAttrSz();
    function WriteXmlAttrSz(_value: any);
    function ReadXmlAttrSpace();
    function WriteXmlAttrSpace(_value: any);
    function ReadXmlAttrColor();
    function WriteXmlAttrColor(_value: any);
    function ReadXmlAttrThemeColor();
    function WriteXmlAttrThemeColor(_value: any);
    function ReadXmlAttrThemeShade();
    function WriteXmlAttrThemeShade(_value: any);
    function ReadXmlAttrThemeTint();
    function WriteXmlAttrThemeTint(_value: any);
    function ReadXmlAttrFrame();
    function WriteXmlAttrFrame(_value: any);
    function ReadXmlAttrShadow();
    function WriteXmlAttrShadow(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;
    XmlAttrSz: OpenXmlAttribute;
    XmlAttrSpace: OpenXmlAttribute;
    XmlAttrColor: OpenXmlAttribute;
    XmlAttrThemeColor: OpenXmlAttribute;
    XmlAttrThemeShade: OpenXmlAttribute;
    XmlAttrThemeTint: OpenXmlAttribute;
    XmlAttrFrame: OpenXmlAttribute;
    XmlAttrShadow: OpenXmlAttribute;

end;

type RFonts = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: RFonts);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Hint read ReadXmlAttrHint write WriteXmlAttrHint;
    property Ascii read ReadXmlAttrAscii write WriteXmlAttrAscii;
    property AsciiTheme read ReadXmlAttrAsciiTheme write WriteXmlAttrAsciiTheme;
    property EastAsia read ReadXmlAttrEastAsia write WriteXmlAttrEastAsia;
    property EastAsiaTheme read ReadXmlAttrEastAsiaTheme write WriteXmlAttrEastAsiaTheme;
    property HAnsi read ReadXmlAttrHAnsi write WriteXmlAttrHAnsi;
    property HAnsiTheme read ReadXmlAttrHAnsiTheme write WriteXmlAttrHAnsiTheme;
    property Cs read ReadXmlAttrCs write WriteXmlAttrCs;
    property CsTheme read ReadXmlAttrCsTheme write WriteXmlAttrCsTheme;
    function ReadXmlAttrHint();
    function WriteXmlAttrHint(_value: any);
    function ReadXmlAttrAscii();
    function WriteXmlAttrAscii(_value: any);
    function ReadXmlAttrAsciiTheme();
    function WriteXmlAttrAsciiTheme(_value: any);
    function ReadXmlAttrEastAsia();
    function WriteXmlAttrEastAsia(_value: any);
    function ReadXmlAttrEastAsiaTheme();
    function WriteXmlAttrEastAsiaTheme(_value: any);
    function ReadXmlAttrHAnsi();
    function WriteXmlAttrHAnsi(_value: any);
    function ReadXmlAttrHAnsiTheme();
    function WriteXmlAttrHAnsiTheme(_value: any);
    function ReadXmlAttrCs();
    function WriteXmlAttrCs(_value: any);
    function ReadXmlAttrCsTheme();
    function WriteXmlAttrCsTheme(_value: any);

public
    // Attributes
    XmlAttrHint: OpenXmlAttribute;
    XmlAttrAscii: OpenXmlAttribute;
    XmlAttrAsciiTheme: OpenXmlAttribute;
    XmlAttrEastAsia: OpenXmlAttribute;
    XmlAttrEastAsiaTheme: OpenXmlAttribute;
    XmlAttrHAnsi: OpenXmlAttribute;
    XmlAttrHAnsiTheme: OpenXmlAttribute;
    XmlAttrCs: OpenXmlAttribute;
    XmlAttrCsTheme: OpenXmlAttribute;

end;

type SzCs = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: SzCs);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;

end;

type Sz = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Sz);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;

end;

type PureVal = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: PureVal);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;

end;

type PureWVal = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: PureWVal);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;

end;

type Color = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Color);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    property ThemeColor read ReadXmlAttrThemeColor write WriteXmlAttrThemeColor;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);
    function ReadXmlAttrThemeColor();
    function WriteXmlAttrThemeColor(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;
    XmlAttrThemeColor: OpenXmlAttribute;

end;

type Lang = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Lang);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    property EastAsia read ReadXmlAttrEastAsia write WriteXmlAttrEastAsia;
    property Bidi read ReadXmlAttrBidi write WriteXmlAttrBidi;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);
    function ReadXmlAttrEastAsia();
    function WriteXmlAttrEastAsia(_value: any);
    function ReadXmlAttrBidi();
    function WriteXmlAttrBidi(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;
    XmlAttrEastAsia: OpenXmlAttribute;
    XmlAttrBidi: OpenXmlAttribute;

end;

type R = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: R);override;
    function ConvertToPoint();override;

public
    // attributes property
    property RsidRPr read ReadXmlAttrRsidRPr write WriteXmlAttrRsidRPr;
    property Anchor read ReadXmlAttrAnchor write WriteXmlAttrAnchor;
    property History read ReadXmlAttrHistory write WriteXmlAttrHistory;
    function ReadXmlAttrRsidRPr();
    function WriteXmlAttrRsidRPr(_value: any);
    function ReadXmlAttrAnchor();
    function WriteXmlAttrAnchor(_value: any);
    function ReadXmlAttrHistory();
    function WriteXmlAttrHistory(_value: any);

    // simple_type property
    property Separator read ReadXmlChildSeparator write WriteXmlChildSeparator;
    property ContinuationSeparator read ReadXmlChildContinuationSeparator write WriteXmlChildContinuationSeparator;
    property LastRenderedPageBreak read ReadXmlChildLastRenderedPageBreak write WriteXmlChildLastRenderedPageBreak;
    property FootnoteRef read ReadXmlChildFootnoteRef write WriteXmlChildFootnoteRef;
    function ReadXmlChildSeparator(): OpenXmlSimpleType;
    function WriteXmlChildSeparator(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildContinuationSeparator(): OpenXmlSimpleType;
    function WriteXmlChildContinuationSeparator(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildLastRenderedPageBreak(): OpenXmlSimpleType;
    function WriteXmlChildLastRenderedPageBreak(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildFootnoteRef(): OpenXmlSimpleType;
    function WriteXmlChildFootnoteRef(_value: nil_or_OpenXmlSimpleType);

    // normal property
    property RPr read ReadXmlChildRPr write WriteXmlChildRPr;
    property Br read ReadXmlChildBr write WriteXmlChildBr;
    property FldChar read ReadXmlChildFldChar write WriteXmlChildFldChar;
    property InstrText read ReadXmlChildInstrText write WriteXmlChildInstrText;
    property AlternateContent read ReadXmlChildAlternateContent write WriteXmlChildAlternateContent;
    property Drawing read ReadXmlChildDrawing write WriteXmlChildDrawing;
    property Pict read ReadXmlChildPict write WriteXmlChildPict;
    property T read ReadXmlChildT write WriteXmlChildT;
    property Object read ReadXmlChildObject write WriteXmlChildObject;
    property FootnoteReference read ReadXmlChildFootnoteReference write WriteXmlChildFootnoteReference;
    property CommentReference read ReadXmlChildCommentReference write WriteXmlChildCommentReference;
    function ReadXmlChildRPr(): RPr;
    function WriteXmlChildRPr(_p1: any; _p2: any);
    function ReadXmlChildBr(): Br;
    function WriteXmlChildBr(_p1: any; _p2: any);
    function ReadXmlChildFldChar(): FldChar;
    function WriteXmlChildFldChar(_p1: any; _p2: any);
    function ReadXmlChildInstrText(): InstrText;
    function WriteXmlChildInstrText(_p1: any; _p2: any);
    function ReadXmlChildAlternateContent(): AlternateContent;
    function WriteXmlChildAlternateContent(_p1: any; _p2: any);
    function ReadXmlChildDrawing(): Drawing;
    function WriteXmlChildDrawing(_p1: any; _p2: any);
    function ReadXmlChildPict(): Pict;
    function WriteXmlChildPict(_p1: any; _p2: any);
    function ReadXmlChildT(): T;
    function WriteXmlChildT(_p1: any; _p2: any);
    function ReadXmlChildObject(): Object;
    function WriteXmlChildObject(_p1: any; _p2: any);
    function ReadXmlChildFootnoteReference(): FootnoteReference;
    function WriteXmlChildFootnoteReference(_p1: any; _p2: any);
    function ReadXmlChildCommentReference(): CommentReference;
    function WriteXmlChildCommentReference(_p1: any; _p2: any);

    // multi property
    property Rs read ReadRs write WriteRs;
    function ReadRs(_index: integer);
    function WriteRs(_index: integer; _value: nil_OR_R);
    function AddR(): R;
    function AppendR(): R;

public
    // Attributes
    XmlAttrRsidRPr: OpenXmlAttribute;
    XmlAttrAnchor: OpenXmlAttribute;
    XmlAttrHistory: OpenXmlAttribute;

    // Children
    XmlChildRPr: RPr;
    XmlChildBr: Br;
    XmlChildFldChar: FldChar;
    XmlChildInstrText: InstrText;
    XmlChildSeparator: OpenXmlSimpleType;
    XmlChildContinuationSeparator: OpenXmlSimpleType;
    XmlChildLastRenderedPageBreak: OpenXmlSimpleType;
    XmlChildAlternateContent: AlternateContent;
    XmlChildDrawing: Drawing;
    XmlChildPict: Pict;
    XmlChildT: T;
    XmlChildObject: Object;
    XmlChildFootnoteReference: FootnoteReference;
    XmlChildFootnoteRef: OpenXmlSimpleType;
    XmlChildCommentReference: CommentReference;
end;

type CommentReference = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: CommentReference);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Id read ReadXmlAttrId write WriteXmlAttrId;
    function ReadXmlAttrId();
    function WriteXmlAttrId(_value: any);

public
    // Attributes
    XmlAttrId: OpenXmlAttribute;

end;

type Object = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Object);override;
    function ConvertToPoint();override;

public
    // attributes property
    property DxaOrig read ReadXmlAttrDxaOrig write WriteXmlAttrDxaOrig;
    property DyaOrig read ReadXmlAttrDyaOrig write WriteXmlAttrDyaOrig;
    property AnchorId read ReadXmlAttrAnchorId write WriteXmlAttrAnchorId;
    function ReadXmlAttrDxaOrig();
    function WriteXmlAttrDxaOrig(_value: any);
    function ReadXmlAttrDyaOrig();
    function WriteXmlAttrDyaOrig(_value: any);
    function ReadXmlAttrAnchorId();
    function WriteXmlAttrAnchorId(_value: any);

    // normal property
    property Shapetype read ReadXmlChildShapetype write WriteXmlChildShapetype;
    property Shape read ReadXmlChildShape write WriteXmlChildShape;
    property OLEObject read ReadXmlChildOLEObject write WriteXmlChildOLEObject;
    function ReadXmlChildShapetype(): Shapetype;
    function WriteXmlChildShapetype(_p1: any; _p2: any);
    function ReadXmlChildShape(): Shape;
    function WriteXmlChildShape(_p1: any; _p2: any);
    function ReadXmlChildOLEObject(): OLEObject;
    function WriteXmlChildOLEObject(_p1: any; _p2: any);

public
    // Attributes
    XmlAttrDxaOrig: OpenXmlAttribute;
    XmlAttrDyaOrig: OpenXmlAttribute;
    XmlAttrAnchorId: OpenXmlAttribute;

    // Children
    XmlChildShapetype: Shapetype;
    XmlChildShape: Shape;
    XmlChildOLEObject: OLEObject;
end;

type FootnoteReference = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: FootnoteReference);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Id read ReadXmlAttrId write WriteXmlAttrId;
    function ReadXmlAttrId();
    function WriteXmlAttrId(_value: any);

public
    // Attributes
    XmlAttrId: OpenXmlAttribute;

end;

type FldChar = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: FldChar);override;
    function ConvertToPoint();override;

public
    // attributes property
    property FldCharType read ReadXmlAttrFldCharType write WriteXmlAttrFldCharType;
    property FldLock read ReadXmlAttrFldLock write WriteXmlAttrFldLock;
    property Dirty read ReadXmlAttrDirty write WriteXmlAttrDirty;
    function ReadXmlAttrFldCharType();
    function WriteXmlAttrFldCharType(_value: any);
    function ReadXmlAttrFldLock();
    function WriteXmlAttrFldLock(_value: any);
    function ReadXmlAttrDirty();
    function WriteXmlAttrDirty(_value: any);

public
    // Attributes
    XmlAttrFldCharType: OpenXmlAttribute;
    XmlAttrFldLock: OpenXmlAttribute;
    XmlAttrDirty: OpenXmlAttribute;

end;

type InstrText = class(OpenXmlTextElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: InstrText);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Space read ReadXmlAttrSpace write WriteXmlAttrSpace;
    function ReadXmlAttrSpace();
    function WriteXmlAttrSpace(_value: any);

public
    // Attributes
    XmlAttrSpace: OpenXmlAttribute;

end;

type Br = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Br);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Type read ReadXmlAttrType write WriteXmlAttrType;
    function ReadXmlAttrType();
    function WriteXmlAttrType(_value: any);

public
    // Attributes
    XmlAttrType: OpenXmlAttribute;

end;

type TxbxContent = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TxbxContent);override;
    function ConvertToPoint();override;

public

    // multi property
    property Ps read ReadPs write WritePs;
    function ReadPs(_index: integer);
    function WritePs(_index: integer; _value: nil_OR_P);
    function AddP(): P;
    function AppendP(): P;

public
    // Children
end;

type Drawing = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Drawing);override;
    function ConvertToPoint();override;

public

    // normal property
    property _Inline read ReadXmlChild_Inline write WriteXmlChild_Inline;
    property Anchor read ReadXmlChildAnchor write WriteXmlChildAnchor;
    function ReadXmlChild_Inline(): _Inline;
    function WriteXmlChild_Inline(_p1: any; _p2: any);
    function ReadXmlChildAnchor(): Anchor;
    function WriteXmlChildAnchor(_p1: any; _p2: any);

public
    // Children
    XmlChild_Inline: _Inline;
    XmlChildAnchor: Anchor;
end;

type T = class(OpenXmlTextElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: T);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Space read ReadXmlAttrSpace write WriteXmlAttrSpace;
    function ReadXmlAttrSpace();
    function WriteXmlAttrSpace(_value: any);

public
    // Attributes
    XmlAttrSpace: OpenXmlAttribute;

end;

type Tbl = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Tbl);override;
    function ConvertToPoint();override;

public

    // normal property
    property TblPr read ReadXmlChildTblPr write WriteXmlChildTblPr;
    property TblGrid read ReadXmlChildTblGrid write WriteXmlChildTblGrid;
    function ReadXmlChildTblPr(): TblPr;
    function WriteXmlChildTblPr(_p1: any; _p2: any);
    function ReadXmlChildTblGrid(): TblGrid;
    function WriteXmlChildTblGrid(_p1: any; _p2: any);

    // multi property
    property Trs read ReadTrs write WriteTrs;
    property Sdts read ReadSdts write WriteSdts;
    function ReadTrs(_index: integer);
    function WriteTrs(_index: integer; _value: nil_OR_Tr);
    function ReadSdts(_index: integer);
    function WriteSdts(_index: integer; _value: nil_OR_Sdt);
    function AddTr(): Tr;
    function AddSdt(): Sdt;
    function AppendTr(): Tr;
    function AppendSdt(): Sdt;

public
    // Children
    XmlChildTblPr: TblPr;
    XmlChildTblGrid: TblGrid;
end;

type TblPr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TblPr);override;
    function ConvertToPoint();override;

public

    // normal property
    property Jc read ReadXmlChildJc write WriteXmlChildJc;
    property Shd read ReadXmlChildShd write WriteXmlChildShd;
    property TblStyle read ReadXmlChildTblStyle write WriteXmlChildTblStyle;
    property TblW read ReadXmlChildTblW write WriteXmlChildTblW;
    property TblInd read ReadXmlChildTblInd write WriteXmlChildTblInd;
    property TblLayout read ReadXmlChildTblLayout write WriteXmlChildTblLayout;
    property TblLook read ReadXmlChildTblLook write WriteXmlChildTblLook;
    property TblBorders read ReadXmlChildTblBorders write WriteXmlChildTblBorders;
    property TblCellMar read ReadXmlChildTblCellMar write WriteXmlChildTblCellMar;
    property TblCellSpacing read ReadXmlChildTblCellSpacing write WriteXmlChildTblCellSpacing;
    property TblCaption read ReadXmlChildTblCaption write WriteXmlChildTblCaption;
    property TblDescription read ReadXmlChildTblDescription write WriteXmlChildTblDescription;
    property TblStyleRowBandSize read ReadXmlChildTblStyleRowBandSize write WriteXmlChildTblStyleRowBandSize;
    property TblStyleColBandSize read ReadXmlChildTblStyleColBandSize write WriteXmlChildTblStyleColBandSize;
    function ReadXmlChildJc(): PureWVal;
    function WriteXmlChildJc(_p1: any; _p2: any);
    function ReadXmlChildShd(): Shd;
    function WriteXmlChildShd(_p1: any; _p2: any);
    function ReadXmlChildTblStyle(): PureWVal;
    function WriteXmlChildTblStyle(_p1: any; _p2: any);
    function ReadXmlChildTblW(): TblW;
    function WriteXmlChildTblW(_p1: any; _p2: any);
    function ReadXmlChildTblInd(): TblW;
    function WriteXmlChildTblInd(_p1: any; _p2: any);
    function ReadXmlChildTblLayout(): TblLayout;
    function WriteXmlChildTblLayout(_p1: any; _p2: any);
    function ReadXmlChildTblLook(): TblLook;
    function WriteXmlChildTblLook(_p1: any; _p2: any);
    function ReadXmlChildTblBorders(): TblBorders;
    function WriteXmlChildTblBorders(_p1: any; _p2: any);
    function ReadXmlChildTblCellMar(): TblCellMar;
    function WriteXmlChildTblCellMar(_p1: any; _p2: any);
    function ReadXmlChildTblCellSpacing(): TblCellSpacing;
    function WriteXmlChildTblCellSpacing(_p1: any; _p2: any);
    function ReadXmlChildTblCaption(): PureWVal;
    function WriteXmlChildTblCaption(_p1: any; _p2: any);
    function ReadXmlChildTblDescription(): PureWVal;
    function WriteXmlChildTblDescription(_p1: any; _p2: any);
    function ReadXmlChildTblStyleRowBandSize(): PureWVal;
    function WriteXmlChildTblStyleRowBandSize(_p1: any; _p2: any);
    function ReadXmlChildTblStyleColBandSize(): PureWVal;
    function WriteXmlChildTblStyleColBandSize(_p1: any; _p2: any);

public
    // Children
    XmlChildJc: PureWVal;
    XmlChildShd: Shd;
    XmlChildTblStyle: PureWVal;
    XmlChildTblW: TblW;
    XmlChildTblInd: TblW;
    XmlChildTblLayout: TblLayout;
    XmlChildTblLook: TblLook;
    XmlChildTblBorders: TblBorders;
    XmlChildTblCellMar: TblCellMar;
    XmlChildTblCellSpacing: TblCellSpacing;
    XmlChildTblCaption: PureWVal;
    XmlChildTblDescription: PureWVal;
    XmlChildTblStyleRowBandSize: PureWVal;
    XmlChildTblStyleColBandSize: PureWVal;
end;

type TblCellSpacing = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TblCellSpacing);override;
    function ConvertToPoint();override;

public
    // attributes property
    property W read ReadXmlAttrW write WriteXmlAttrW;
    property Type read ReadXmlAttrType write WriteXmlAttrType;
    function ReadXmlAttrW();
    function WriteXmlAttrW(_value: any);
    function ReadXmlAttrType();
    function WriteXmlAttrType(_value: any);

public
    // Attributes
    XmlAttrW: OpenXmlAttribute;
    XmlAttrType: OpenXmlAttribute;

end;

type TblW = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TblW);override;
    function ConvertToPoint();override;

public
    // attributes property
    property W read ReadXmlAttrW write WriteXmlAttrW;
    property Type read ReadXmlAttrType write WriteXmlAttrType;
    function ReadXmlAttrW();
    function WriteXmlAttrW(_value: any);
    function ReadXmlAttrType();
    function WriteXmlAttrType(_value: any);

public
    // Attributes
    XmlAttrW: OpenXmlAttribute;
    XmlAttrType: OpenXmlAttribute;

end;

type TblLayout = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TblLayout);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Type read ReadXmlAttrType write WriteXmlAttrType;
    function ReadXmlAttrType();
    function WriteXmlAttrType(_value: any);

public
    // Attributes
    XmlAttrType: OpenXmlAttribute;

end;

type TblLook = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TblLook);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    property FirstRow read ReadXmlAttrFirstRow write WriteXmlAttrFirstRow;
    property LastRow read ReadXmlAttrLastRow write WriteXmlAttrLastRow;
    property FirstColumn read ReadXmlAttrFirstColumn write WriteXmlAttrFirstColumn;
    property LastColumn read ReadXmlAttrLastColumn write WriteXmlAttrLastColumn;
    property NoHBand read ReadXmlAttrNoHBand write WriteXmlAttrNoHBand;
    property NoVBand read ReadXmlAttrNoVBand write WriteXmlAttrNoVBand;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);
    function ReadXmlAttrFirstRow();
    function WriteXmlAttrFirstRow(_value: any);
    function ReadXmlAttrLastRow();
    function WriteXmlAttrLastRow(_value: any);
    function ReadXmlAttrFirstColumn();
    function WriteXmlAttrFirstColumn(_value: any);
    function ReadXmlAttrLastColumn();
    function WriteXmlAttrLastColumn(_value: any);
    function ReadXmlAttrNoHBand();
    function WriteXmlAttrNoHBand(_value: any);
    function ReadXmlAttrNoVBand();
    function WriteXmlAttrNoVBand(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;
    XmlAttrFirstRow: OpenXmlAttribute;
    XmlAttrLastRow: OpenXmlAttribute;
    XmlAttrFirstColumn: OpenXmlAttribute;
    XmlAttrLastColumn: OpenXmlAttribute;
    XmlAttrNoHBand: OpenXmlAttribute;
    XmlAttrNoVBand: OpenXmlAttribute;

end;

type TblBorders = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TblBorders);override;
    function ConvertToPoint();override;

public

    // normal property
    property Top read ReadXmlChildTop write WriteXmlChildTop;
    property Left read ReadXmlChildLeft write WriteXmlChildLeft;
    property Bottom read ReadXmlChildBottom write WriteXmlChildBottom;
    property Right read ReadXmlChildRight write WriteXmlChildRight;
    property InsideH read ReadXmlChildInsideH write WriteXmlChildInsideH;
    property InsideV read ReadXmlChildInsideV write WriteXmlChildInsideV;
    function ReadXmlChildTop(): TblBorder;
    function WriteXmlChildTop(_p1: any; _p2: any);
    function ReadXmlChildLeft(): TblBorder;
    function WriteXmlChildLeft(_p1: any; _p2: any);
    function ReadXmlChildBottom(): TblBorder;
    function WriteXmlChildBottom(_p1: any; _p2: any);
    function ReadXmlChildRight(): TblBorder;
    function WriteXmlChildRight(_p1: any; _p2: any);
    function ReadXmlChildInsideH(): TblBorder;
    function WriteXmlChildInsideH(_p1: any; _p2: any);
    function ReadXmlChildInsideV(): TblBorder;
    function WriteXmlChildInsideV(_p1: any; _p2: any);

public
    // Children
    XmlChildTop: TblBorder;
    XmlChildLeft: TblBorder;
    XmlChildBottom: TblBorder;
    XmlChildRight: TblBorder;
    XmlChildInsideH: TblBorder;
    XmlChildInsideV: TblBorder;
end;

type TblBorder = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TblBorder);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    property Color read ReadXmlAttrColor write WriteXmlAttrColor;
    property Space read ReadXmlAttrSpace write WriteXmlAttrSpace;
    property ThemeColor read ReadXmlAttrThemeColor write WriteXmlAttrThemeColor;
    property ThemeTint read ReadXmlAttrThemeTint write WriteXmlAttrThemeTint;
    property Sz read ReadXmlAttrSz write WriteXmlAttrSz;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);
    function ReadXmlAttrColor();
    function WriteXmlAttrColor(_value: any);
    function ReadXmlAttrSpace();
    function WriteXmlAttrSpace(_value: any);
    function ReadXmlAttrThemeColor();
    function WriteXmlAttrThemeColor(_value: any);
    function ReadXmlAttrThemeTint();
    function WriteXmlAttrThemeTint(_value: any);
    function ReadXmlAttrSz();
    function WriteXmlAttrSz(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;
    XmlAttrColor: OpenXmlAttribute;
    XmlAttrSpace: OpenXmlAttribute;
    XmlAttrThemeColor: OpenXmlAttribute;
    XmlAttrThemeTint: OpenXmlAttribute;
    XmlAttrSz: OpenXmlAttribute;

end;

type TblGrid = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TblGrid);override;
    function ConvertToPoint();override;

public

    // multi property
    property GridCols read ReadGridCols write WriteGridCols;
    function ReadGridCols(_index: integer);
    function WriteGridCols(_index: integer; _value: nil_OR_GridCol);
    function AddGridCol(): GridCol;
    function AppendGridCol(): GridCol;

public
    // Children
end;

type GridCol = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: GridCol);override;
    function ConvertToPoint();override;

public
    // attributes property
    property w read ReadXmlAttrw write WriteXmlAttrw;
    function ReadXmlAttrw();
    function WriteXmlAttrw(_value: any);

public
    // Attributes
    XmlAttrw: OpenXmlAttribute;

end;

type Tr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Tr);override;
    function ConvertToPoint();override;

public
    // attributes property
    property RsidR read ReadXmlAttrRsidR write WriteXmlAttrRsidR;
    property ParaId read ReadXmlAttrParaId write WriteXmlAttrParaId;
    property TextId read ReadXmlAttrTextId write WriteXmlAttrTextId;
    property RsidTr read ReadXmlAttrRsidTr write WriteXmlAttrRsidTr;
    function ReadXmlAttrRsidR();
    function WriteXmlAttrRsidR(_value: any);
    function ReadXmlAttrParaId();
    function WriteXmlAttrParaId(_value: any);
    function ReadXmlAttrTextId();
    function WriteXmlAttrTextId(_value: any);
    function ReadXmlAttrRsidTr();
    function WriteXmlAttrRsidTr(_value: any);

    // normal property
    property TrPr read ReadXmlChildTrPr write WriteXmlChildTrPr;
    function ReadXmlChildTrPr(): TrPr;
    function WriteXmlChildTrPr(_p1: any; _p2: any);

    // multi property
    property Sdts read ReadSdts write WriteSdts;
    property Tcs read ReadTcs write WriteTcs;
    function ReadSdts(_index: integer);
    function WriteSdts(_index: integer; _value: nil_OR_Sdt);
    function ReadTcs(_index: integer);
    function WriteTcs(_index: integer; _value: nil_OR_Tc);
    function AddSdt(): Sdt;
    function AddTc(): Tc;
    function AppendSdt(): Sdt;
    function AppendTc(): Tc;

public
    // Attributes
    XmlAttrRsidR: OpenXmlAttribute;
    XmlAttrParaId: OpenXmlAttribute;
    XmlAttrTextId: OpenXmlAttribute;
    XmlAttrRsidTr: OpenXmlAttribute;

    // Children
    XmlChildTrPr: TrPr;
end;

type TrPr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TrPr);override;
    function ConvertToPoint();override;

public

    // simple_type property
    property TblHeader read ReadXmlChildTblHeader write WriteXmlChildTblHeader;
    property CantSplit read ReadXmlChildCantSplit write WriteXmlChildCantSplit;
    function ReadXmlChildTblHeader(): OpenXmlSimpleType;
    function WriteXmlChildTblHeader(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildCantSplit(): OpenXmlSimpleType;
    function WriteXmlChildCantSplit(_value: nil_or_OpenXmlSimpleType);

    // normal property
    property TrHeight read ReadXmlChildTrHeight write WriteXmlChildTrHeight;
    property Jc read ReadXmlChildJc write WriteXmlChildJc;
    property CnfStyle read ReadXmlChildCnfStyle write WriteXmlChildCnfStyle;
    property Ins read ReadXmlChildIns write WriteXmlChildIns;
    property Del read ReadXmlChildDel write WriteXmlChildDel;
    function ReadXmlChildTrHeight(): TrHeight;
    function WriteXmlChildTrHeight(_p1: any; _p2: any);
    function ReadXmlChildJc(): PureWVal;
    function WriteXmlChildJc(_p1: any; _p2: any);
    function ReadXmlChildCnfStyle(): CnfStyle;
    function WriteXmlChildCnfStyle(_p1: any; _p2: any);
    function ReadXmlChildIns(): Ins;
    function WriteXmlChildIns(_p1: any; _p2: any);
    function ReadXmlChildDel(): Del;
    function WriteXmlChildDel(_p1: any; _p2: any);

public
    // Children
    XmlChildTrHeight: TrHeight;
    XmlChildTblHeader: OpenXmlSimpleType;
    XmlChildJc: PureWVal;
    XmlChildCantSplit: OpenXmlSimpleType;
    XmlChildCnfStyle: CnfStyle;
    XmlChildIns: Ins;
    XmlChildDel: Del;
end;

type Ins = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Ins);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Id read ReadXmlAttrId write WriteXmlAttrId;
    property Author read ReadXmlAttrAuthor write WriteXmlAttrAuthor;
    property Date read ReadXmlAttrDate write WriteXmlAttrDate;
    property DateUtc read ReadXmlAttrDateUtc write WriteXmlAttrDateUtc;
    function ReadXmlAttrId();
    function WriteXmlAttrId(_value: any);
    function ReadXmlAttrAuthor();
    function WriteXmlAttrAuthor(_value: any);
    function ReadXmlAttrDate();
    function WriteXmlAttrDate(_value: any);
    function ReadXmlAttrDateUtc();
    function WriteXmlAttrDateUtc(_value: any);

    // multi property
    property Rs read ReadRs write WriteRs;
    function ReadRs(_index: integer);
    function WriteRs(_index: integer; _value: nil_OR_R);
    function AddR(): R;
    function AppendR(): R;

public
    // Attributes
    XmlAttrId: OpenXmlAttribute;
    XmlAttrAuthor: OpenXmlAttribute;
    XmlAttrDate: OpenXmlAttribute;
    XmlAttrDateUtc: OpenXmlAttribute;

    // Children
end;

type CnfStyle = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: CnfStyle);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    property FirstRow read ReadXmlAttrFirstRow write WriteXmlAttrFirstRow;
    property LastRow read ReadXmlAttrLastRow write WriteXmlAttrLastRow;
    property FirstColumn read ReadXmlAttrFirstColumn write WriteXmlAttrFirstColumn;
    property LastColumn read ReadXmlAttrLastColumn write WriteXmlAttrLastColumn;
    property OddVBand read ReadXmlAttrOddVBand write WriteXmlAttrOddVBand;
    property EvenVBand read ReadXmlAttrEvenVBand write WriteXmlAttrEvenVBand;
    property OddHBand read ReadXmlAttrOddHBand write WriteXmlAttrOddHBand;
    property EvenHBand read ReadXmlAttrEvenHBand write WriteXmlAttrEvenHBand;
    property FirstRowFirstColumn read ReadXmlAttrFirstRowFirstColumn write WriteXmlAttrFirstRowFirstColumn;
    property FirstRowLastColumn read ReadXmlAttrFirstRowLastColumn write WriteXmlAttrFirstRowLastColumn;
    property LastRowFirstColumn read ReadXmlAttrLastRowFirstColumn write WriteXmlAttrLastRowFirstColumn;
    property LastRowLastColumn read ReadXmlAttrLastRowLastColumn write WriteXmlAttrLastRowLastColumn;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);
    function ReadXmlAttrFirstRow();
    function WriteXmlAttrFirstRow(_value: any);
    function ReadXmlAttrLastRow();
    function WriteXmlAttrLastRow(_value: any);
    function ReadXmlAttrFirstColumn();
    function WriteXmlAttrFirstColumn(_value: any);
    function ReadXmlAttrLastColumn();
    function WriteXmlAttrLastColumn(_value: any);
    function ReadXmlAttrOddVBand();
    function WriteXmlAttrOddVBand(_value: any);
    function ReadXmlAttrEvenVBand();
    function WriteXmlAttrEvenVBand(_value: any);
    function ReadXmlAttrOddHBand();
    function WriteXmlAttrOddHBand(_value: any);
    function ReadXmlAttrEvenHBand();
    function WriteXmlAttrEvenHBand(_value: any);
    function ReadXmlAttrFirstRowFirstColumn();
    function WriteXmlAttrFirstRowFirstColumn(_value: any);
    function ReadXmlAttrFirstRowLastColumn();
    function WriteXmlAttrFirstRowLastColumn(_value: any);
    function ReadXmlAttrLastRowFirstColumn();
    function WriteXmlAttrLastRowFirstColumn(_value: any);
    function ReadXmlAttrLastRowLastColumn();
    function WriteXmlAttrLastRowLastColumn(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;
    XmlAttrFirstRow: OpenXmlAttribute;
    XmlAttrLastRow: OpenXmlAttribute;
    XmlAttrFirstColumn: OpenXmlAttribute;
    XmlAttrLastColumn: OpenXmlAttribute;
    XmlAttrOddVBand: OpenXmlAttribute;
    XmlAttrEvenVBand: OpenXmlAttribute;
    XmlAttrOddHBand: OpenXmlAttribute;
    XmlAttrEvenHBand: OpenXmlAttribute;
    XmlAttrFirstRowFirstColumn: OpenXmlAttribute;
    XmlAttrFirstRowLastColumn: OpenXmlAttribute;
    XmlAttrLastRowFirstColumn: OpenXmlAttribute;
    XmlAttrLastRowLastColumn: OpenXmlAttribute;

end;

type TrHeight = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TrHeight);override;
    function ConvertToPoint();override;

public
    // attributes property
    property HRule read ReadXmlAttrHRule write WriteXmlAttrHRule;
    property val read ReadXmlAttrval write WriteXmlAttrval;
    function ReadXmlAttrHRule();
    function WriteXmlAttrHRule(_value: any);
    function ReadXmlAttrval();
    function WriteXmlAttrval(_value: any);

public
    // Attributes
    XmlAttrHRule: OpenXmlAttribute;
    XmlAttrval: OpenXmlAttribute;

end;

type Tc = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Tc);override;
    function ConvertToPoint();override;

public

    // normal property
    property TcPr read ReadXmlChildTcPr write WriteXmlChildTcPr;
    function ReadXmlChildTcPr(): TcPr;
    function WriteXmlChildTcPr(_p1: any; _p2: any);

    // multi property
    property Ps read ReadPs write WritePs;
    property Tbls read ReadTbls write WriteTbls;
    function ReadPs(_index: integer);
    function WritePs(_index: integer; _value: nil_OR_P);
    function ReadTbls(_index: integer);
    function WriteTbls(_index: integer; _value: nil_OR_Tbl);
    function AddP(): P;
    function AddTbl(): Tbl;
    function AppendP(): P;
    function AppendTbl(): Tbl;

public
    // Children
    XmlChildTcPr: TcPr;
end;

type TcPr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TcPr);override;
    function ConvertToPoint();override;

public

    // simple_type property
    property VMerge read ReadXmlChildVMerge write WriteXmlChildVMerge;
    property HideMark read ReadXmlChildHideMark write WriteXmlChildHideMark;
    function ReadXmlChildVMerge(): OpenXmlSimpleType;
    function WriteXmlChildVMerge(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildHideMark(): OpenXmlSimpleType;
    function WriteXmlChildHideMark(_value: nil_or_OpenXmlSimpleType);

    // normal property
    property TcW read ReadXmlChildTcW write WriteXmlChildTcW;
    property GridSpan read ReadXmlChildGridSpan write WriteXmlChildGridSpan;
    property VAlign read ReadXmlChildVAlign write WriteXmlChildVAlign;
    property Shd read ReadXmlChildShd write WriteXmlChildShd;
    property TcBorders read ReadXmlChildTcBorders write WriteXmlChildTcBorders;
    property TextDirection read ReadXmlChildTextDirection write WriteXmlChildTextDirection;
    function ReadXmlChildTcW(): TblW;
    function WriteXmlChildTcW(_p1: any; _p2: any);
    function ReadXmlChildGridSpan(): GridSpan;
    function WriteXmlChildGridSpan(_p1: any; _p2: any);
    function ReadXmlChildVAlign(): PureWVal;
    function WriteXmlChildVAlign(_p1: any; _p2: any);
    function ReadXmlChildShd(): Shd;
    function WriteXmlChildShd(_p1: any; _p2: any);
    function ReadXmlChildTcBorders(): TcBorders;
    function WriteXmlChildTcBorders(_p1: any; _p2: any);
    function ReadXmlChildTextDirection(): PureWVal;
    function WriteXmlChildTextDirection(_p1: any; _p2: any);

public
    // Children
    XmlChildTcW: TblW;
    XmlChildGridSpan: GridSpan;
    XmlChildVMerge: OpenXmlSimpleType;
    XmlChildVAlign: PureWVal;
    XmlChildHideMark: OpenXmlSimpleType;
    XmlChildShd: Shd;
    XmlChildTcBorders: TcBorders;
    XmlChildTextDirection: PureWVal;
end;

type TcBorders = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TcBorders);override;
    function ConvertToPoint();override;

public

    // normal property
    property Top read ReadXmlChildTop write WriteXmlChildTop;
    property Left read ReadXmlChildLeft write WriteXmlChildLeft;
    property Bottom read ReadXmlChildBottom write WriteXmlChildBottom;
    property Right read ReadXmlChildRight write WriteXmlChildRight;
    property Tl2Br read ReadXmlChildTl2Br write WriteXmlChildTl2Br;
    property Tr2Bl read ReadXmlChildTr2Bl write WriteXmlChildTr2Bl;
    property InsideH read ReadXmlChildInsideH write WriteXmlChildInsideH;
    property InsideV read ReadXmlChildInsideV write WriteXmlChildInsideV;
    function ReadXmlChildTop(): TcBorder;
    function WriteXmlChildTop(_p1: any; _p2: any);
    function ReadXmlChildLeft(): TcBorder;
    function WriteXmlChildLeft(_p1: any; _p2: any);
    function ReadXmlChildBottom(): TcBorder;
    function WriteXmlChildBottom(_p1: any; _p2: any);
    function ReadXmlChildRight(): TcBorder;
    function WriteXmlChildRight(_p1: any; _p2: any);
    function ReadXmlChildTl2Br(): TcBorder;
    function WriteXmlChildTl2Br(_p1: any; _p2: any);
    function ReadXmlChildTr2Bl(): TcBorder;
    function WriteXmlChildTr2Bl(_p1: any; _p2: any);
    function ReadXmlChildInsideH(): TcBorder;
    function WriteXmlChildInsideH(_p1: any; _p2: any);
    function ReadXmlChildInsideV(): TcBorder;
    function WriteXmlChildInsideV(_p1: any; _p2: any);

public
    // Children
    XmlChildTop: TcBorder;
    XmlChildLeft: TcBorder;
    XmlChildBottom: TcBorder;
    XmlChildRight: TcBorder;
    XmlChildTl2Br: TcBorder;
    XmlChildTr2Bl: TcBorder;
    XmlChildInsideH: TcBorder;
    XmlChildInsideV: TcBorder;
end;

type TcBorder = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TcBorder);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    property Color read ReadXmlAttrColor write WriteXmlAttrColor;
    property Space read ReadXmlAttrSpace write WriteXmlAttrSpace;
    property ThemeColor read ReadXmlAttrThemeColor write WriteXmlAttrThemeColor;
    property ThemeTint read ReadXmlAttrThemeTint write WriteXmlAttrThemeTint;
    property Sz read ReadXmlAttrSz write WriteXmlAttrSz;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);
    function ReadXmlAttrColor();
    function WriteXmlAttrColor(_value: any);
    function ReadXmlAttrSpace();
    function WriteXmlAttrSpace(_value: any);
    function ReadXmlAttrThemeColor();
    function WriteXmlAttrThemeColor(_value: any);
    function ReadXmlAttrThemeTint();
    function WriteXmlAttrThemeTint(_value: any);
    function ReadXmlAttrSz();
    function WriteXmlAttrSz(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;
    XmlAttrColor: OpenXmlAttribute;
    XmlAttrSpace: OpenXmlAttribute;
    XmlAttrThemeColor: OpenXmlAttribute;
    XmlAttrThemeTint: OpenXmlAttribute;
    XmlAttrSz: OpenXmlAttribute;

end;

type GridSpan = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: GridSpan);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;

end;

type Sdt = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Sdt);override;
    function ConvertToPoint();override;

public

    // normal property
    property SdtPr read ReadXmlChildSdtPr write WriteXmlChildSdtPr;
    property SdtEndPr read ReadXmlChildSdtEndPr write WriteXmlChildSdtEndPr;
    property SdtContent read ReadXmlChildSdtContent write WriteXmlChildSdtContent;
    function ReadXmlChildSdtPr(): SdtPr;
    function WriteXmlChildSdtPr(_p1: any; _p2: any);
    function ReadXmlChildSdtEndPr(): SdtEndPr;
    function WriteXmlChildSdtEndPr(_p1: any; _p2: any);
    function ReadXmlChildSdtContent(): SdtContent;
    function WriteXmlChildSdtContent(_p1: any; _p2: any);

public
    // Children
    XmlChildSdtPr: SdtPr;
    XmlChildSdtEndPr: SdtEndPr;
    XmlChildSdtContent: SdtContent;
end;

type SdtPr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: SdtPr);override;
    function ConvertToPoint();override;

public

    // normal property
    property RPr read ReadXmlChildRPr write WriteXmlChildRPr;
    property Id read ReadXmlChildId write WriteXmlChildId;
    property DocPartObj read ReadXmlChildDocPartObj write WriteXmlChildDocPartObj;
    function ReadXmlChildRPr(): RPr;
    function WriteXmlChildRPr(_p1: any; _p2: any);
    function ReadXmlChildId(): PureWVal;
    function WriteXmlChildId(_p1: any; _p2: any);
    function ReadXmlChildDocPartObj(): DocPartObj;
    function WriteXmlChildDocPartObj(_p1: any; _p2: any);

public
    // Children
    XmlChildRPr: RPr;
    XmlChildId: PureWVal;
    XmlChildDocPartObj: DocPartObj;
end;

type DocPartObj = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: DocPartObj);override;
    function ConvertToPoint();override;

public

    // normal property
    property DocPartGallery read ReadXmlChildDocPartGallery write WriteXmlChildDocPartGallery;
    property DocPartUnique read ReadXmlChildDocPartUnique write WriteXmlChildDocPartUnique;
    function ReadXmlChildDocPartGallery(): PureWVal;
    function WriteXmlChildDocPartGallery(_p1: any; _p2: any);
    function ReadXmlChildDocPartUnique(): PureVal;
    function WriteXmlChildDocPartUnique(_p1: any; _p2: any);

public
    // Children
    XmlChildDocPartGallery: PureWVal;
    XmlChildDocPartUnique: PureVal;
end;

type SdtEndPr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: SdtEndPr);override;
    function ConvertToPoint();override;

public

    // normal property
    property RPr read ReadXmlChildRPr write WriteXmlChildRPr;
    function ReadXmlChildRPr(): RPr;
    function WriteXmlChildRPr(_p1: any; _p2: any);

public
    // Children
    XmlChildRPr: RPr;
end;

type SdtContent = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: SdtContent);override;
    function ConvertToPoint();override;

public

    // normal property
    property Sdt read ReadXmlChildSdt write WriteXmlChildSdt;
    function ReadXmlChildSdt(): Sdt;
    function WriteXmlChildSdt(_p1: any; _p2: any);

    // multi property
    property Ps read ReadPs write WritePs;
    property Rs read ReadRs write WriteRs;
    function ReadPs(_index: integer);
    function WritePs(_index: integer; _value: nil_OR_P);
    function ReadRs(_index: integer);
    function WriteRs(_index: integer; _value: nil_OR_R);
    function AddP(): P;
    function AddR(): R;
    function AppendP(): P;
    function AppendR(): R;

public
    // Children
    XmlChildSdt: Sdt;
end;

type SectPr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: SectPr);override;
    function ConvertToPoint();override;

public
    // attributes property
    property RsidR read ReadXmlAttrRsidR write WriteXmlAttrRsidR;
    property RsidSect read ReadXmlAttrRsidSect write WriteXmlAttrRsidSect;
    function ReadXmlAttrRsidR();
    function WriteXmlAttrRsidR(_value: any);
    function ReadXmlAttrRsidSect();
    function WriteXmlAttrRsidSect(_value: any);

    // simple_type property
    property TitlePg read ReadXmlChildTitlePg write WriteXmlChildTitlePg;
    function ReadXmlChildTitlePg(): OpenXmlSimpleType;
    function WriteXmlChildTitlePg(_value: nil_or_OpenXmlSimpleType);

    // normal property
    property FootnotePr read ReadXmlChildFootnotePr write WriteXmlChildFootnotePr;
    property EndnotePr read ReadXmlChildEndnotePr write WriteXmlChildEndnotePr;
    property Type read ReadXmlChildType write WriteXmlChildType;
    property PgSz read ReadXmlChildPgSz write WriteXmlChildPgSz;
    property PgMar read ReadXmlChildPgMar write WriteXmlChildPgMar;
    property PgNumType read ReadXmlChildPgNumType write WriteXmlChildPgNumType;
    property Cols read ReadXmlChildCols write WriteXmlChildCols;
    property DocGrid read ReadXmlChildDocGrid write WriteXmlChildDocGrid;
    property TextDirection read ReadXmlChildTextDirection write WriteXmlChildTextDirection;
    function ReadXmlChildFootnotePr(): FootnotePr;
    function WriteXmlChildFootnotePr(_p1: any; _p2: any);
    function ReadXmlChildEndnotePr(): EndnotePr;
    function WriteXmlChildEndnotePr(_p1: any; _p2: any);
    function ReadXmlChildType(): PureWVal;
    function WriteXmlChildType(_p1: any; _p2: any);
    function ReadXmlChildPgSz(): PgSz;
    function WriteXmlChildPgSz(_p1: any; _p2: any);
    function ReadXmlChildPgMar(): PgMar;
    function WriteXmlChildPgMar(_p1: any; _p2: any);
    function ReadXmlChildPgNumType(): PgNumType;
    function WriteXmlChildPgNumType(_p1: any; _p2: any);
    function ReadXmlChildCols(): Cols;
    function WriteXmlChildCols(_p1: any; _p2: any);
    function ReadXmlChildDocGrid(): DocGrid;
    function WriteXmlChildDocGrid(_p1: any; _p2: any);
    function ReadXmlChildTextDirection(): PureWVal;
    function WriteXmlChildTextDirection(_p1: any; _p2: any);

    // multi property
    property HeaderReferences read ReadHeaderReferences write WriteHeaderReferences;
    property FooterReferences read ReadFooterReferences write WriteFooterReferences;
    function ReadHeaderReferences(_index: integer);
    function WriteHeaderReferences(_index: integer; _value: nil_OR_Reference);
    function ReadFooterReferences(_index: integer);
    function WriteFooterReferences(_index: integer; _value: nil_OR_Reference);
    function AddHeaderReference(): Reference;
    function AddFooterReference(): Reference;
    function AppendHeaderReference(): Reference;
    function AppendFooterReference(): Reference;

public
    // Attributes
    XmlAttrRsidR: OpenXmlAttribute;
    XmlAttrRsidSect: OpenXmlAttribute;

    // Children
    XmlChildFootnotePr: FootnotePr;
    XmlChildEndnotePr: EndnotePr;
    XmlChildType: PureWVal;
    XmlChildPgSz: PgSz;
    XmlChildPgMar: PgMar;
    XmlChildPgNumType: PgNumType;
    XmlChildCols: Cols;
    XmlChildTitlePg: OpenXmlSimpleType;
    XmlChildDocGrid: DocGrid;
    XmlChildTextDirection: PureWVal;
end;

type Reference = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Reference);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Type read ReadXmlAttrType write WriteXmlAttrType;
    property Id read ReadXmlAttrId write WriteXmlAttrId;
    function ReadXmlAttrType();
    function WriteXmlAttrType(_value: any);
    function ReadXmlAttrId();
    function WriteXmlAttrId(_value: any);

public
    // Attributes
    XmlAttrType: OpenXmlAttribute;
    XmlAttrId: OpenXmlAttribute;

end;

type PgNumType = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: PgNumType);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Start read ReadXmlAttrStart write WriteXmlAttrStart;
    function ReadXmlAttrStart();
    function WriteXmlAttrStart(_value: any);

public
    // Attributes
    XmlAttrStart: OpenXmlAttribute;

end;

type PgSz = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: PgSz);override;
    function ConvertToPoint();override;

public
    // attributes property
    property W read ReadXmlAttrW write WriteXmlAttrW;
    property H read ReadXmlAttrH write WriteXmlAttrH;
    property Orient read ReadXmlAttrOrient write WriteXmlAttrOrient;
    property Code read ReadXmlAttrCode write WriteXmlAttrCode;
    function ReadXmlAttrW();
    function WriteXmlAttrW(_value: any);
    function ReadXmlAttrH();
    function WriteXmlAttrH(_value: any);
    function ReadXmlAttrOrient();
    function WriteXmlAttrOrient(_value: any);
    function ReadXmlAttrCode();
    function WriteXmlAttrCode(_value: any);

public
    // Attributes
    XmlAttrW: OpenXmlAttribute;
    XmlAttrH: OpenXmlAttribute;
    XmlAttrOrient: OpenXmlAttribute;
    XmlAttrCode: OpenXmlAttribute;

end;

type PgMar = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: PgMar);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Top read ReadXmlAttrTop write WriteXmlAttrTop;
    property Right read ReadXmlAttrRight write WriteXmlAttrRight;
    property Bottom read ReadXmlAttrBottom write WriteXmlAttrBottom;
    property Left read ReadXmlAttrLeft write WriteXmlAttrLeft;
    property Header read ReadXmlAttrHeader write WriteXmlAttrHeader;
    property Footer read ReadXmlAttrFooter write WriteXmlAttrFooter;
    property Gutter read ReadXmlAttrGutter write WriteXmlAttrGutter;
    function ReadXmlAttrTop();
    function WriteXmlAttrTop(_value: any);
    function ReadXmlAttrRight();
    function WriteXmlAttrRight(_value: any);
    function ReadXmlAttrBottom();
    function WriteXmlAttrBottom(_value: any);
    function ReadXmlAttrLeft();
    function WriteXmlAttrLeft(_value: any);
    function ReadXmlAttrHeader();
    function WriteXmlAttrHeader(_value: any);
    function ReadXmlAttrFooter();
    function WriteXmlAttrFooter(_value: any);
    function ReadXmlAttrGutter();
    function WriteXmlAttrGutter(_value: any);

public
    // Attributes
    XmlAttrTop: OpenXmlAttribute;
    XmlAttrRight: OpenXmlAttribute;
    XmlAttrBottom: OpenXmlAttribute;
    XmlAttrLeft: OpenXmlAttribute;
    XmlAttrHeader: OpenXmlAttribute;
    XmlAttrFooter: OpenXmlAttribute;
    XmlAttrGutter: OpenXmlAttribute;

end;

type Cols = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Cols);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Num read ReadXmlAttrNum write WriteXmlAttrNum;
    property Space read ReadXmlAttrSpace write WriteXmlAttrSpace;
    property EqualWidth read ReadXmlAttrEqualWidth write WriteXmlAttrEqualWidth;
    function ReadXmlAttrNum();
    function WriteXmlAttrNum(_value: any);
    function ReadXmlAttrSpace();
    function WriteXmlAttrSpace(_value: any);
    function ReadXmlAttrEqualWidth();
    function WriteXmlAttrEqualWidth(_value: any);

    // multi property
    property Cols read ReadCols write WriteCols;
    function ReadCols(_index: integer);
    function WriteCols(_index: integer; _value: nil_OR_Col);
    function AddCol(): Col;
    function AppendCol(): Col;

public
    // Attributes
    XmlAttrNum: OpenXmlAttribute;
    XmlAttrSpace: OpenXmlAttribute;
    XmlAttrEqualWidth: OpenXmlAttribute;

    // Children
end;

type Col = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Col);override;
    function ConvertToPoint();override;

public
    // attributes property
    property W read ReadXmlAttrW write WriteXmlAttrW;
    property Space read ReadXmlAttrSpace write WriteXmlAttrSpace;
    function ReadXmlAttrW();
    function WriteXmlAttrW(_value: any);
    function ReadXmlAttrSpace();
    function WriteXmlAttrSpace(_value: any);

public
    // Attributes
    XmlAttrW: OpenXmlAttribute;
    XmlAttrSpace: OpenXmlAttribute;

end;

type DocGrid = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: DocGrid);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Type read ReadXmlAttrType write WriteXmlAttrType;
    property LinePitch read ReadXmlAttrLinePitch write WriteXmlAttrLinePitch;
    function ReadXmlAttrType();
    function WriteXmlAttrType(_value: any);
    function ReadXmlAttrLinePitch();
    function WriteXmlAttrLinePitch(_value: any);

public
    // Attributes
    XmlAttrType: OpenXmlAttribute;
    XmlAttrLinePitch: OpenXmlAttribute;

end;

type Endnotes = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Endnotes);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Ignorable read ReadXmlAttrIgnorable write WriteXmlAttrIgnorable;
    function ReadXmlAttrIgnorable();
    function WriteXmlAttrIgnorable(_value: any);

    // multi property
    property Endnotes read ReadEndnotes write WriteEndnotes;
    function ReadEndnotes(_index: integer);
    function WriteEndnotes(_index: integer; _value: nil_OR_Endnote);
    function AddEndnote(): Endnote;
    function AppendEndnote(): Endnote;

public
    // Attributes
    XmlAttrIgnorable: OpenXmlAttribute;

    // Children
end;

type Endnote = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Endnote);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Type read ReadXmlAttrType write WriteXmlAttrType;
    property Id read ReadXmlAttrId write WriteXmlAttrId;
    function ReadXmlAttrType();
    function WriteXmlAttrType(_value: any);
    function ReadXmlAttrId();
    function WriteXmlAttrId(_value: any);

    // multi property
    property Ps read ReadPs write WritePs;
    function ReadPs(_index: integer);
    function WritePs(_index: integer; _value: nil_OR_P);
    function AddP(): P;
    function AppendP(): P;

public
    // Attributes
    XmlAttrType: OpenXmlAttribute;
    XmlAttrId: OpenXmlAttribute;

    // Children
end;

type Footnotes = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Footnotes);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Ignorable read ReadXmlAttrIgnorable write WriteXmlAttrIgnorable;
    function ReadXmlAttrIgnorable();
    function WriteXmlAttrIgnorable(_value: any);

    // multi property
    property Footnotes read ReadFootnotes write WriteFootnotes;
    function ReadFootnotes(_index: integer);
    function WriteFootnotes(_index: integer; _value: nil_OR_Footnote);
    function AddFootnote(): Footnote;
    function AppendFootnote(): Footnote;

public
    // Attributes
    XmlAttrIgnorable: OpenXmlAttribute;

    // Children
end;

type Footnote = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Footnote);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Type read ReadXmlAttrType write WriteXmlAttrType;
    property Id read ReadXmlAttrId write WriteXmlAttrId;
    function ReadXmlAttrType();
    function WriteXmlAttrType(_value: any);
    function ReadXmlAttrId();
    function WriteXmlAttrId(_value: any);

    // multi property
    property Ps read ReadPs write WritePs;
    function ReadPs(_index: integer);
    function WritePs(_index: integer; _value: nil_OR_P);
    function AddP(): P;
    function AppendP(): P;

public
    // Attributes
    XmlAttrType: OpenXmlAttribute;
    XmlAttrId: OpenXmlAttribute;

    // Children
end;

type Fonts = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Fonts);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Ignorable read ReadXmlAttrIgnorable write WriteXmlAttrIgnorable;
    function ReadXmlAttrIgnorable();
    function WriteXmlAttrIgnorable(_value: any);

    // multi property
    property Fonts read ReadFonts write WriteFonts;
    function ReadFonts(_index: integer);
    function WriteFonts(_index: integer; _value: nil_OR_Font);
    function AddFont(): Font;
    function AppendFont(): Font;

public
    // Attributes
    XmlAttrIgnorable: OpenXmlAttribute;

    // Children
end;

type Font = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Font);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Name read ReadXmlAttrName write WriteXmlAttrName;
    function ReadXmlAttrName();
    function WriteXmlAttrName(_value: any);

    // normal property
    property AltName read ReadXmlChildAltName write WriteXmlChildAltName;
    property Panosel read ReadXmlChildPanosel write WriteXmlChildPanosel;
    property Charset read ReadXmlChildCharset write WriteXmlChildCharset;
    property Family read ReadXmlChildFamily write WriteXmlChildFamily;
    property Pitch read ReadXmlChildPitch write WriteXmlChildPitch;
    property Sig read ReadXmlChildSig write WriteXmlChildSig;
    function ReadXmlChildAltName(): PureWVal;
    function WriteXmlChildAltName(_p1: any; _p2: any);
    function ReadXmlChildPanosel(): PureWVal;
    function WriteXmlChildPanosel(_p1: any; _p2: any);
    function ReadXmlChildCharset(): PureWVal;
    function WriteXmlChildCharset(_p1: any; _p2: any);
    function ReadXmlChildFamily(): PureWVal;
    function WriteXmlChildFamily(_p1: any; _p2: any);
    function ReadXmlChildPitch(): PureWVal;
    function WriteXmlChildPitch(_p1: any; _p2: any);
    function ReadXmlChildSig(): Sig;
    function WriteXmlChildSig(_p1: any; _p2: any);

public
    // Attributes
    XmlAttrName: OpenXmlAttribute;

    // Children
    XmlChildAltName: PureWVal;
    XmlChildPanosel: PureWVal;
    XmlChildCharset: PureWVal;
    XmlChildFamily: PureWVal;
    XmlChildPitch: PureWVal;
    XmlChildSig: Sig;
end;

type Sig = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Sig);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Usb0 read ReadXmlAttrUsb0 write WriteXmlAttrUsb0;
    property Usb1 read ReadXmlAttrUsb1 write WriteXmlAttrUsb1;
    property Usb2 read ReadXmlAttrUsb2 write WriteXmlAttrUsb2;
    property Usb3 read ReadXmlAttrUsb3 write WriteXmlAttrUsb3;
    property Csb0 read ReadXmlAttrCsb0 write WriteXmlAttrCsb0;
    property Csb1 read ReadXmlAttrCsb1 write WriteXmlAttrCsb1;
    function ReadXmlAttrUsb0();
    function WriteXmlAttrUsb0(_value: any);
    function ReadXmlAttrUsb1();
    function WriteXmlAttrUsb1(_value: any);
    function ReadXmlAttrUsb2();
    function WriteXmlAttrUsb2(_value: any);
    function ReadXmlAttrUsb3();
    function WriteXmlAttrUsb3(_value: any);
    function ReadXmlAttrCsb0();
    function WriteXmlAttrCsb0(_value: any);
    function ReadXmlAttrCsb1();
    function WriteXmlAttrCsb1(_value: any);

public
    // Attributes
    XmlAttrUsb0: OpenXmlAttribute;
    XmlAttrUsb1: OpenXmlAttribute;
    XmlAttrUsb2: OpenXmlAttribute;
    XmlAttrUsb3: OpenXmlAttribute;
    XmlAttrCsb0: OpenXmlAttribute;
    XmlAttrCsb1: OpenXmlAttribute;

end;

type Settings = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Settings);override;
    function ConvertToPoint();override;

public
    // attributes property
    property MCIgnorable read ReadXmlAttrMCIgnorable write WriteXmlAttrMCIgnorable;
    property IgnorableN read ReadXmlAttrIgnorableN write WriteXmlAttrIgnorableN;
    property Ignorable read ReadXmlAttrIgnorable write WriteXmlAttrIgnorable;
    property MCPr read ReadXmlAttrMCPr write WriteXmlAttrMCPr;
    property Pr read ReadXmlAttrPr write WriteXmlAttrPr;
    property XSig read ReadXmlAttrXSig write WriteXmlAttrXSig;
    property MCSig read ReadXmlAttrMCSig write WriteXmlAttrMCSig;
    property SigN read ReadXmlAttrSigN write WriteXmlAttrSigN;
    function ReadXmlAttrMCIgnorable();
    function WriteXmlAttrMCIgnorable(_value: any);
    function ReadXmlAttrIgnorableN();
    function WriteXmlAttrIgnorableN(_value: any);
    function ReadXmlAttrIgnorable(_ns: string);
    function WriteXmlAttrIgnorable(_p1: any; _p2: any);
    function ReadXmlAttrMCPr();
    function WriteXmlAttrMCPr(_value: any);
    function ReadXmlAttrPr(_ns: string);
    function WriteXmlAttrPr(_p1: any; _p2: any);
    function ReadXmlAttrXSig();
    function WriteXmlAttrXSig(_value: any);
    function ReadXmlAttrMCSig();
    function WriteXmlAttrMCSig(_value: any);
    function ReadXmlAttrSigN();
    function WriteXmlAttrSigN(_value: any);

    // simple_type property
    property ChartTrackingRefBased read ReadXmlChildChartTrackingRefBased write WriteXmlChildChartTrackingRefBased;
    function ReadXmlChildChartTrackingRefBased(): OpenXmlSimpleType;
    function WriteXmlChildChartTrackingRefBased(_value: nil_or_OpenXmlSimpleType);

    // normal property
    property DocId read ReadXmlChildDocId write WriteXmlChildDocId;
    property W14DocId read ReadXmlChildW14DocId write WriteXmlChildW14DocId;
    property W15DocId read ReadXmlChildW15DocId write WriteXmlChildW15DocId;
    function ReadXmlChildDocId(_ns: string): PureWVal;
    function WriteXmlChildDocId(_p1: any; _p2: any);
    function ReadXmlChildW14DocId(): PureWVal;
    function WriteXmlChildW14DocId(_p1: any; _p2: any);
    function ReadXmlChildW15DocId(): PureWVal;
    function WriteXmlChildW15DocId(_p1: any; _p2: any);

public
    // Attributes
    XmlAttrMCIgnorable: OpenXmlAttribute;
    XmlAttrIgnorableN: OpenXmlAttribute;
    XmlAttrIgnorable: OpenXmlAttribute;
    XmlAttrMCPr: OpenXmlAttribute;
    XmlAttrPr: OpenXmlAttribute;
    XmlAttrXSig: OpenXmlAttribute;
    XmlAttrMCSig: OpenXmlAttribute;
    XmlAttrSigN: OpenXmlAttribute;

    // Children
    XmlChildDocId: PureWVal;
    XmlChildW14DocId: PureWVal;
    XmlChildW15DocId: PureWVal;
    XmlChildChartTrackingRefBased: OpenXmlSimpleType;
end;

type Zoom = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Zoom);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Percent read ReadXmlAttrPercent write WriteXmlAttrPercent;
    function ReadXmlAttrPercent();
    function WriteXmlAttrPercent(_value: any);

public
    // Attributes
    XmlAttrPercent: OpenXmlAttribute;

end;

type HdrShapeDefaults = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: HdrShapeDefaults);override;
    function ConvertToPoint();override;

public

    // normal property
    property ShapeDefaults read ReadXmlChildShapeDefaults write WriteXmlChildShapeDefaults;
    function ReadXmlChildShapeDefaults(): ShapeDefaults;
    function WriteXmlChildShapeDefaults(_p1: any; _p2: any);

public
    // Children
    XmlChildShapeDefaults: ShapeDefaults;
end;

type ShapeDefaults = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: ShapeDefaults);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Ext read ReadXmlAttrExt write WriteXmlAttrExt;
    property Spidmax read ReadXmlAttrSpidmax write WriteXmlAttrSpidmax;
    function ReadXmlAttrExt();
    function WriteXmlAttrExt(_value: any);
    function ReadXmlAttrSpidmax();
    function WriteXmlAttrSpidmax(_value: any);

public
    // Attributes
    XmlAttrExt: OpenXmlAttribute;
    XmlAttrSpidmax: OpenXmlAttribute;

end;

type FootnotePr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: FootnotePr);override;
    function ConvertToPoint();override;

public

    // normal property
    property Pos read ReadXmlChildPos write WriteXmlChildPos;
    property NumFmt read ReadXmlChildNumFmt write WriteXmlChildNumFmt;
    property NumStart read ReadXmlChildNumStart write WriteXmlChildNumStart;
    property NumRestart read ReadXmlChildNumRestart write WriteXmlChildNumRestart;
    function ReadXmlChildPos(): PureWVal;
    function WriteXmlChildPos(_p1: any; _p2: any);
    function ReadXmlChildNumFmt(): PureWVal;
    function WriteXmlChildNumFmt(_p1: any; _p2: any);
    function ReadXmlChildNumStart(): PureWVal;
    function WriteXmlChildNumStart(_p1: any; _p2: any);
    function ReadXmlChildNumRestart(): PureWVal;
    function WriteXmlChildNumRestart(_p1: any; _p2: any);

    // multi property
    property Footnotes read ReadFootnotes write WriteFootnotes;
    function ReadFootnotes(_index: integer);
    function WriteFootnotes(_index: integer; _value: nil_OR_Footnote);
    function AddFootnote(): Footnote;
    function AppendFootnote(): Footnote;

public
    // Children
    XmlChildPos: PureWVal;
    XmlChildNumFmt: PureWVal;
    XmlChildNumStart: PureWVal;
    XmlChildNumRestart: PureWVal;
end;

type EndnotePr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: EndnotePr);override;
    function ConvertToPoint();override;

public

    // normal property
    property Pos read ReadXmlChildPos write WriteXmlChildPos;
    property NumFmt read ReadXmlChildNumFmt write WriteXmlChildNumFmt;
    property NumStart read ReadXmlChildNumStart write WriteXmlChildNumStart;
    property NumRestart read ReadXmlChildNumRestart write WriteXmlChildNumRestart;
    function ReadXmlChildPos(): PureWVal;
    function WriteXmlChildPos(_p1: any; _p2: any);
    function ReadXmlChildNumFmt(): PureWVal;
    function WriteXmlChildNumFmt(_p1: any; _p2: any);
    function ReadXmlChildNumStart(): PureWVal;
    function WriteXmlChildNumStart(_p1: any; _p2: any);
    function ReadXmlChildNumRestart(): PureWVal;
    function WriteXmlChildNumRestart(_p1: any; _p2: any);

    // multi property
    property Footnotes read ReadFootnotes write WriteFootnotes;
    function ReadFootnotes(_index: integer);
    function WriteFootnotes(_index: integer; _value: nil_OR_Footnote);
    function AddFootnote(): Footnote;
    function AppendFootnote(): Footnote;

public
    // Children
    XmlChildPos: PureWVal;
    XmlChildNumFmt: PureWVal;
    XmlChildNumStart: PureWVal;
    XmlChildNumRestart: PureWVal;
end;

type Compat = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Compat);override;
    function ConvertToPoint();override;

public

    // simple_type property
    property SpaceForUL read ReadXmlChildSpaceForUL write WriteXmlChildSpaceForUL;
    property BalanceSingleByteDoubleByteWidth read ReadXmlChildBalanceSingleByteDoubleByteWidth write WriteXmlChildBalanceSingleByteDoubleByteWidth;
    property DoNotLeaveBackslashAlone read ReadXmlChildDoNotLeaveBackslashAlone write WriteXmlChildDoNotLeaveBackslashAlone;
    property UlTrailSpace read ReadXmlChildUlTrailSpace write WriteXmlChildUlTrailSpace;
    property DoNotExpandShiftReturn read ReadXmlChildDoNotExpandShiftReturn write WriteXmlChildDoNotExpandShiftReturn;
    property AdjustLineHeightInTable read ReadXmlChildAdjustLineHeightInTable write WriteXmlChildAdjustLineHeightInTable;
    property UseFELayout read ReadXmlChildUseFELayout write WriteXmlChildUseFELayout;
    property CompatSetting read ReadXmlChildCompatSetting write WriteXmlChildCompatSetting;
    function ReadXmlChildSpaceForUL(): OpenXmlSimpleType;
    function WriteXmlChildSpaceForUL(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildBalanceSingleByteDoubleByteWidth(): OpenXmlSimpleType;
    function WriteXmlChildBalanceSingleByteDoubleByteWidth(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildDoNotLeaveBackslashAlone(): OpenXmlSimpleType;
    function WriteXmlChildDoNotLeaveBackslashAlone(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildUlTrailSpace(): OpenXmlSimpleType;
    function WriteXmlChildUlTrailSpace(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildDoNotExpandShiftReturn(): OpenXmlSimpleType;
    function WriteXmlChildDoNotExpandShiftReturn(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildAdjustLineHeightInTable(): OpenXmlSimpleType;
    function WriteXmlChildAdjustLineHeightInTable(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildUseFELayout(): OpenXmlSimpleType;
    function WriteXmlChildUseFELayout(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildCompatSetting(): OpenXmlSimpleType;
    function WriteXmlChildCompatSetting(_value: nil_or_OpenXmlSimpleType);

    // multi property
    property CompatSettings read ReadCompatSettings write WriteCompatSettings;
    function ReadCompatSettings(_index: integer);
    function WriteCompatSettings(_index: integer; _value: nil_OR_CompatSetting);
    function AddCompatSetting(): CompatSetting;
    function AppendCompatSetting(): CompatSetting;

public
    // Children
    XmlChildSpaceForUL: OpenXmlSimpleType;
    XmlChildBalanceSingleByteDoubleByteWidth: OpenXmlSimpleType;
    XmlChildDoNotLeaveBackslashAlone: OpenXmlSimpleType;
    XmlChildUlTrailSpace: OpenXmlSimpleType;
    XmlChildDoNotExpandShiftReturn: OpenXmlSimpleType;
    XmlChildAdjustLineHeightInTable: OpenXmlSimpleType;
    XmlChildUseFELayout: OpenXmlSimpleType;
end;

type CompatSetting = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: CompatSetting);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Name read ReadXmlAttrName write WriteXmlAttrName;
    property Uri read ReadXmlAttrUri write WriteXmlAttrUri;
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    function ReadXmlAttrName();
    function WriteXmlAttrName(_value: any);
    function ReadXmlAttrUri();
    function WriteXmlAttrUri(_value: any);
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);

public
    // Attributes
    XmlAttrName: OpenXmlAttribute;
    XmlAttrUri: OpenXmlAttribute;
    XmlAttrVal: OpenXmlAttribute;

end;

type Rsids = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Rsids);override;
    function ConvertToPoint();override;

public

    // normal property
    property RsidRoot read ReadXmlChildRsidRoot write WriteXmlChildRsidRoot;
    function ReadXmlChildRsidRoot(): PureWVal;
    function WriteXmlChildRsidRoot(_p1: any; _p2: any);

    // multi property
    property Rsids read ReadRsids write WriteRsids;
    function ReadRsids(_index: integer);
    function WriteRsids(_index: integer; _value: nil_OR_PureWVal);
    function AddRsid(): PureWVal;
    function AppendRsid(): PureWVal;

public
    // Children
    XmlChildRsidRoot: PureWVal;
end;

type ThemeFontLang = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: ThemeFontLang);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    property EastAsia read ReadXmlAttrEastAsia write WriteXmlAttrEastAsia;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value: any);
    function ReadXmlAttrEastAsia();
    function WriteXmlAttrEastAsia(_value: any);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;
    XmlAttrEastAsia: OpenXmlAttribute;

end;

type ClrSchemeMapping = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: ClrSchemeMapping);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Bg1 read ReadXmlAttrBg1 write WriteXmlAttrBg1;
    property T1 read ReadXmlAttrT1 write WriteXmlAttrT1;
    property Bg2 read ReadXmlAttrBg2 write WriteXmlAttrBg2;
    property T2 read ReadXmlAttrT2 write WriteXmlAttrT2;
    property Accent1 read ReadXmlAttrAccent1 write WriteXmlAttrAccent1;
    property Accent2 read ReadXmlAttrAccent2 write WriteXmlAttrAccent2;
    property Accent3 read ReadXmlAttrAccent3 write WriteXmlAttrAccent3;
    property Accent4 read ReadXmlAttrAccent4 write WriteXmlAttrAccent4;
    property Accent5 read ReadXmlAttrAccent5 write WriteXmlAttrAccent5;
    property Accent6 read ReadXmlAttrAccent6 write WriteXmlAttrAccent6;
    property HyperLink read ReadXmlAttrHyperLink write WriteXmlAttrHyperLink;
    property FollowedHyperlink read ReadXmlAttrFollowedHyperlink write WriteXmlAttrFollowedHyperlink;
    function ReadXmlAttrBg1();
    function WriteXmlAttrBg1(_value: any);
    function ReadXmlAttrT1();
    function WriteXmlAttrT1(_value: any);
    function ReadXmlAttrBg2();
    function WriteXmlAttrBg2(_value: any);
    function ReadXmlAttrT2();
    function WriteXmlAttrT2(_value: any);
    function ReadXmlAttrAccent1();
    function WriteXmlAttrAccent1(_value: any);
    function ReadXmlAttrAccent2();
    function WriteXmlAttrAccent2(_value: any);
    function ReadXmlAttrAccent3();
    function WriteXmlAttrAccent3(_value: any);
    function ReadXmlAttrAccent4();
    function WriteXmlAttrAccent4(_value: any);
    function ReadXmlAttrAccent5();
    function WriteXmlAttrAccent5(_value: any);
    function ReadXmlAttrAccent6();
    function WriteXmlAttrAccent6(_value: any);
    function ReadXmlAttrHyperLink();
    function WriteXmlAttrHyperLink(_value: any);
    function ReadXmlAttrFollowedHyperlink();
    function WriteXmlAttrFollowedHyperlink(_value: any);

public
    // Attributes
    XmlAttrBg1: OpenXmlAttribute;
    XmlAttrT1: OpenXmlAttribute;
    XmlAttrBg2: OpenXmlAttribute;
    XmlAttrT2: OpenXmlAttribute;
    XmlAttrAccent1: OpenXmlAttribute;
    XmlAttrAccent2: OpenXmlAttribute;
    XmlAttrAccent3: OpenXmlAttribute;
    XmlAttrAccent4: OpenXmlAttribute;
    XmlAttrAccent5: OpenXmlAttribute;
    XmlAttrAccent6: OpenXmlAttribute;
    XmlAttrHyperLink: OpenXmlAttribute;
    XmlAttrFollowedHyperlink: OpenXmlAttribute;

end;

type ShapeDefaults2 = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: ShapeDefaults2);override;
    function ConvertToPoint();override;

public

    // normal property
    property ShapeDefaults read ReadXmlChildShapeDefaults write WriteXmlChildShapeDefaults;
    property ShapeLayout read ReadXmlChildShapeLayout write WriteXmlChildShapeLayout;
    function ReadXmlChildShapeDefaults(): ShapeDefaults;
    function WriteXmlChildShapeDefaults(_p1: any; _p2: any);
    function ReadXmlChildShapeLayout(): ShapeLayout;
    function WriteXmlChildShapeLayout(_p1: any; _p2: any);

public
    // Children
    XmlChildShapeDefaults: ShapeDefaults;
    XmlChildShapeLayout: ShapeLayout;
end;

type ShapeLayout = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: ShapeLayout);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Ext read ReadXmlAttrExt write WriteXmlAttrExt;
    function ReadXmlAttrExt();
    function WriteXmlAttrExt(_value: any);

    // normal property
    property IdMap read ReadXmlChildIdMap write WriteXmlChildIdMap;
    function ReadXmlChildIdMap(): IdMap;
    function WriteXmlChildIdMap(_p1: any; _p2: any);

public
    // Attributes
    XmlAttrExt: OpenXmlAttribute;

    // Children
    XmlChildIdMap: IdMap;
end;

type IdMap = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: IdMap);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Ext read ReadXmlAttrExt write WriteXmlAttrExt;
    property Data read ReadXmlAttrData write WriteXmlAttrData;
    function ReadXmlAttrExt();
    function WriteXmlAttrExt(_value: any);
    function ReadXmlAttrData();
    function WriteXmlAttrData(_value: any);

public
    // Attributes
    XmlAttrExt: OpenXmlAttribute;
    XmlAttrData: OpenXmlAttribute;

end;

type Styles = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Styles);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Ignorable read ReadXmlAttrIgnorable write WriteXmlAttrIgnorable;
    function ReadXmlAttrIgnorable();
    function WriteXmlAttrIgnorable(_value: any);

    // normal property
    property DocDefaults read ReadXmlChildDocDefaults write WriteXmlChildDocDefaults;
    property LatenStyles read ReadXmlChildLatenStyles write WriteXmlChildLatenStyles;
    function ReadXmlChildDocDefaults(): DocDefaults;
    function WriteXmlChildDocDefaults(_p1: any; _p2: any);
    function ReadXmlChildLatenStyles(): LatenStyles;
    function WriteXmlChildLatenStyles(_p1: any; _p2: any);

    // multi property
    property Styles read ReadStyles write WriteStyles;
    function ReadStyles(_index: integer);
    function WriteStyles(_index: integer; _value: nil_OR_Style);
    function AddStyle(): Style;
    function AppendStyle(): Style;

public
    // Attributes
    XmlAttrIgnorable: OpenXmlAttribute;

    // Children
    XmlChildDocDefaults: DocDefaults;
    XmlChildLatenStyles: LatenStyles;
end;

type DocDefaults = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: DocDefaults);override;
    function ConvertToPoint();override;

public

    // normal property
    property RPrDefault read ReadXmlChildRPrDefault write WriteXmlChildRPrDefault;
    property PPrDefault read ReadXmlChildPPrDefault write WriteXmlChildPPrDefault;
    function ReadXmlChildRPrDefault(): RPrDefault;
    function WriteXmlChildRPrDefault(_p1: any; _p2: any);
    function ReadXmlChildPPrDefault(): PPrDefault;
    function WriteXmlChildPPrDefault(_p1: any; _p2: any);

public
    // Children
    XmlChildRPrDefault: RPrDefault;
    XmlChildPPrDefault: PPrDefault;
end;

type RPrDefault = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: RPrDefault);override;
    function ConvertToPoint();override;

public

    // normal property
    property RPr read ReadXmlChildRPr write WriteXmlChildRPr;
    function ReadXmlChildRPr(): RPr;
    function WriteXmlChildRPr(_p1: any; _p2: any);

public
    // Children
    XmlChildRPr: RPr;
end;

type PPrDefault = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: PPrDefault);override;
    function ConvertToPoint();override;

public

    // normal property
    property PPr read ReadXmlChildPPr write WriteXmlChildPPr;
    function ReadXmlChildPPr(): PPr;
    function WriteXmlChildPPr(_p1: any; _p2: any);

public
    // Children
    XmlChildPPr: PPr;
end;

type LatenStyles = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: LatenStyles);override;
    function ConvertToPoint();override;

public
    // attributes property
    property DefLickedState read ReadXmlAttrDefLickedState write WriteXmlAttrDefLickedState;
    property DefUIPriority read ReadXmlAttrDefUIPriority write WriteXmlAttrDefUIPriority;
    property DefSemiHidden read ReadXmlAttrDefSemiHidden write WriteXmlAttrDefSemiHidden;
    property DefUnhideWhenUsed read ReadXmlAttrDefUnhideWhenUsed write WriteXmlAttrDefUnhideWhenUsed;
    property DefQFormat read ReadXmlAttrDefQFormat write WriteXmlAttrDefQFormat;
    property Count read ReadXmlAttrCount write WriteXmlAttrCount;
    function ReadXmlAttrDefLickedState();
    function WriteXmlAttrDefLickedState(_value: any);
    function ReadXmlAttrDefUIPriority();
    function WriteXmlAttrDefUIPriority(_value: any);
    function ReadXmlAttrDefSemiHidden();
    function WriteXmlAttrDefSemiHidden(_value: any);
    function ReadXmlAttrDefUnhideWhenUsed();
    function WriteXmlAttrDefUnhideWhenUsed(_value: any);
    function ReadXmlAttrDefQFormat();
    function WriteXmlAttrDefQFormat(_value: any);
    function ReadXmlAttrCount();
    function WriteXmlAttrCount(_value: any);

    // multi property
    property LsdExceptions read ReadLsdExceptions write WriteLsdExceptions;
    function ReadLsdExceptions(_index: integer);
    function WriteLsdExceptions(_index: integer; _value: nil_OR_LsdException);
    function AddLsdException(): LsdException;
    function AppendLsdException(): LsdException;

public
    // Attributes
    XmlAttrDefLickedState: OpenXmlAttribute;
    XmlAttrDefUIPriority: OpenXmlAttribute;
    XmlAttrDefSemiHidden: OpenXmlAttribute;
    XmlAttrDefUnhideWhenUsed: OpenXmlAttribute;
    XmlAttrDefQFormat: OpenXmlAttribute;
    XmlAttrCount: OpenXmlAttribute;

    // Children
end;

type LsdException = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: LsdException);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Name read ReadXmlAttrName write WriteXmlAttrName;
    property UIPriority read ReadXmlAttrUIPriority write WriteXmlAttrUIPriority;
    property SemiHidden read ReadXmlAttrSemiHidden write WriteXmlAttrSemiHidden;
    property UnhideWhenUsed read ReadXmlAttrUnhideWhenUsed write WriteXmlAttrUnhideWhenUsed;
    property QFormat read ReadXmlAttrQFormat write WriteXmlAttrQFormat;
    function ReadXmlAttrName();
    function WriteXmlAttrName(_value: any);
    function ReadXmlAttrUIPriority();
    function WriteXmlAttrUIPriority(_value: any);
    function ReadXmlAttrSemiHidden();
    function WriteXmlAttrSemiHidden(_value: any);
    function ReadXmlAttrUnhideWhenUsed();
    function WriteXmlAttrUnhideWhenUsed(_value: any);
    function ReadXmlAttrQFormat();
    function WriteXmlAttrQFormat(_value: any);

public
    // Attributes
    XmlAttrName: OpenXmlAttribute;
    XmlAttrUIPriority: OpenXmlAttribute;
    XmlAttrSemiHidden: OpenXmlAttribute;
    XmlAttrUnhideWhenUsed: OpenXmlAttribute;
    XmlAttrQFormat: OpenXmlAttribute;

end;

type Style = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Style);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Type read ReadXmlAttrType write WriteXmlAttrType;
    property Default read ReadXmlAttrDefault write WriteXmlAttrDefault;
    property StyleId read ReadXmlAttrStyleId write WriteXmlAttrStyleId;
    function ReadXmlAttrType();
    function WriteXmlAttrType(_value: any);
    function ReadXmlAttrDefault();
    function WriteXmlAttrDefault(_value: any);
    function ReadXmlAttrStyleId();
    function WriteXmlAttrStyleId(_value: any);

    // simple_type property
    property SemiHidden read ReadXmlChildSemiHidden write WriteXmlChildSemiHidden;
    property UnhideWhenUsed read ReadXmlChildUnhideWhenUsed write WriteXmlChildUnhideWhenUsed;
    property QFormat read ReadXmlChildQFormat write WriteXmlChildQFormat;
    property Rsid read ReadXmlChildRsid write WriteXmlChildRsid;
    function ReadXmlChildSemiHidden(): OpenXmlSimpleType;
    function WriteXmlChildSemiHidden(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildUnhideWhenUsed(): OpenXmlSimpleType;
    function WriteXmlChildUnhideWhenUsed(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildQFormat(): OpenXmlSimpleType;
    function WriteXmlChildQFormat(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildRsid(): OpenXmlSimpleType;
    function WriteXmlChildRsid(_value: nil_or_OpenXmlSimpleType);

    // normal property
    property Name read ReadXmlChildName write WriteXmlChildName;
    property BasedOn read ReadXmlChildBasedOn write WriteXmlChildBasedOn;
    property Next read ReadXmlChildNext write WriteXmlChildNext;
    property AutoRedefine read ReadXmlChildAutoRedefine write WriteXmlChildAutoRedefine;
    property Link read ReadXmlChildLink write WriteXmlChildLink;
    property UIPriority read ReadXmlChildUIPriority write WriteXmlChildUIPriority;
    property PPr read ReadXmlChildPPr write WriteXmlChildPPr;
    property RPr read ReadXmlChildRPr write WriteXmlChildRPr;
    property TblPr read ReadXmlChildTblPr write WriteXmlChildTblPr;
    property TrPr read ReadXmlChildTrPr write WriteXmlChildTrPr;
    property TcPr read ReadXmlChildTcPr write WriteXmlChildTcPr;
    function ReadXmlChildName(): PureWVal;
    function WriteXmlChildName(_p1: any; _p2: any);
    function ReadXmlChildBasedOn(): PureWVal;
    function WriteXmlChildBasedOn(_p1: any; _p2: any);
    function ReadXmlChildNext(): PureWVal;
    function WriteXmlChildNext(_p1: any; _p2: any);
    function ReadXmlChildAutoRedefine(): PureWVal;
    function WriteXmlChildAutoRedefine(_p1: any; _p2: any);
    function ReadXmlChildLink(): PureWVal;
    function WriteXmlChildLink(_p1: any; _p2: any);
    function ReadXmlChildUIPriority(): PureWVal;
    function WriteXmlChildUIPriority(_p1: any; _p2: any);
    function ReadXmlChildPPr(): PPr;
    function WriteXmlChildPPr(_p1: any; _p2: any);
    function ReadXmlChildRPr(): RPr;
    function WriteXmlChildRPr(_p1: any; _p2: any);
    function ReadXmlChildTblPr(): TblPr;
    function WriteXmlChildTblPr(_p1: any; _p2: any);
    function ReadXmlChildTrPr(): TrPr;
    function WriteXmlChildTrPr(_p1: any; _p2: any);
    function ReadXmlChildTcPr(): TcPr;
    function WriteXmlChildTcPr(_p1: any; _p2: any);

    // multi property
    property TblStylePrs read ReadTblStylePrs write WriteTblStylePrs;
    function ReadTblStylePrs(_index: integer);
    function WriteTblStylePrs(_index: integer; _value: nil_OR_TblStylePr);
    function AddTblStylePr(): TblStylePr;
    function AppendTblStylePr(): TblStylePr;

public
    // Attributes
    XmlAttrType: OpenXmlAttribute;
    XmlAttrDefault: OpenXmlAttribute;
    XmlAttrStyleId: OpenXmlAttribute;

    // Children
    XmlChildName: PureWVal;
    XmlChildBasedOn: PureWVal;
    XmlChildNext: PureWVal;
    XmlChildAutoRedefine: PureWVal;
    XmlChildLink: PureWVal;
    XmlChildUIPriority: PureWVal;
    XmlChildSemiHidden: OpenXmlSimpleType;
    XmlChildUnhideWhenUsed: OpenXmlSimpleType;
    XmlChildQFormat: OpenXmlSimpleType;
    XmlChildRsid: OpenXmlSimpleType;
    XmlChildPPr: PPr;
    XmlChildRPr: RPr;
    XmlChildTblPr: TblPr;
    XmlChildTrPr: TrPr;
    XmlChildTcPr: TcPr;
end;

type TblStylePr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TblStylePr);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Type read ReadXmlAttrType write WriteXmlAttrType;
    function ReadXmlAttrType();
    function WriteXmlAttrType(_value: any);

    // normal property
    property PPr read ReadXmlChildPPr write WriteXmlChildPPr;
    property RPr read ReadXmlChildRPr write WriteXmlChildRPr;
    property TblPr read ReadXmlChildTblPr write WriteXmlChildTblPr;
    property TrPr read ReadXmlChildTrPr write WriteXmlChildTrPr;
    property TcPr read ReadXmlChildTcPr write WriteXmlChildTcPr;
    function ReadXmlChildPPr(): PPr;
    function WriteXmlChildPPr(_p1: any; _p2: any);
    function ReadXmlChildRPr(): RPr;
    function WriteXmlChildRPr(_p1: any; _p2: any);
    function ReadXmlChildTblPr(): TblPr;
    function WriteXmlChildTblPr(_p1: any; _p2: any);
    function ReadXmlChildTrPr(): TrPr;
    function WriteXmlChildTrPr(_p1: any; _p2: any);
    function ReadXmlChildTcPr(): TcPr;
    function WriteXmlChildTcPr(_p1: any; _p2: any);

public
    // Attributes
    XmlAttrType: OpenXmlAttribute;

    // Children
    XmlChildPPr: PPr;
    XmlChildRPr: RPr;
    XmlChildTblPr: TblPr;
    XmlChildTrPr: TrPr;
    XmlChildTcPr: TcPr;
end;

type TblInd = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TblInd);override;
    function ConvertToPoint();override;

public
    // attributes property
    property W read ReadXmlAttrW write WriteXmlAttrW;
    property Type read ReadXmlAttrType write WriteXmlAttrType;
    function ReadXmlAttrW();
    function WriteXmlAttrW(_value: any);
    function ReadXmlAttrType();
    function WriteXmlAttrType(_value: any);

public
    // Attributes
    XmlAttrW: OpenXmlAttribute;
    XmlAttrType: OpenXmlAttribute;

end;

type TblCellMar = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: TblCellMar);override;
    function ConvertToPoint();override;

public

    // normal property
    property Top read ReadXmlChildTop write WriteXmlChildTop;
    property Left read ReadXmlChildLeft write WriteXmlChildLeft;
    property Bottom read ReadXmlChildBottom write WriteXmlChildBottom;
    property Right read ReadXmlChildRight write WriteXmlChildRight;
    function ReadXmlChildTop(): TblInd;
    function WriteXmlChildTop(_p1: any; _p2: any);
    function ReadXmlChildLeft(): TblInd;
    function WriteXmlChildLeft(_p1: any; _p2: any);
    function ReadXmlChildBottom(): TblInd;
    function WriteXmlChildBottom(_p1: any; _p2: any);
    function ReadXmlChildRight(): TblInd;
    function WriteXmlChildRight(_p1: any; _p2: any);

public
    // Children
    XmlChildTop: TblInd;
    XmlChildLeft: TblInd;
    XmlChildBottom: TblInd;
    XmlChildRight: TblInd;
end;

type WebSettings = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: WebSettings);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Ignorable read ReadXmlAttrIgnorable write WriteXmlAttrIgnorable;
    function ReadXmlAttrIgnorable();
    function WriteXmlAttrIgnorable(_value: any);

    // simple_type property
    property OptimizeForBrowser read ReadXmlChildOptimizeForBrowser write WriteXmlChildOptimizeForBrowser;
    property AllowPNG read ReadXmlChildAllowPNG write WriteXmlChildAllowPNG;
    function ReadXmlChildOptimizeForBrowser(): OpenXmlSimpleType;
    function WriteXmlChildOptimizeForBrowser(_value: nil_or_OpenXmlSimpleType);
    function ReadXmlChildAllowPNG(): OpenXmlSimpleType;
    function WriteXmlChildAllowPNG(_value: nil_or_OpenXmlSimpleType);

public
    // Attributes
    XmlAttrIgnorable: OpenXmlAttribute;

    // Children
    XmlChildOptimizeForBrowser: OpenXmlSimpleType;
    XmlChildAllowPNG: OpenXmlSimpleType;
end;

type AlternateContent = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: AlternateContent);override;
    function ConvertToPoint();override;

public

    // normal property
    property Choice read ReadXmlChildChoice write WriteXmlChildChoice;
    property Fallback read ReadXmlChildFallback write WriteXmlChildFallback;
    function ReadXmlChildChoice(): Choice;
    function WriteXmlChildChoice(_p1: any; _p2: any);
    function ReadXmlChildFallback(): Fallback;
    function WriteXmlChildFallback(_p1: any; _p2: any);

public
    // Children
    XmlChildChoice: Choice;
    XmlChildFallback: Fallback;
end;

type Choice = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Choice);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Requires read ReadXmlAttrRequires write WriteXmlAttrRequires;
    function ReadXmlAttrRequires();
    function WriteXmlAttrRequires(_value: any);

    // normal property
    property Style read ReadXmlChildStyle write WriteXmlChildStyle;
    property Drawing read ReadXmlChildDrawing write WriteXmlChildDrawing;
    function ReadXmlChildStyle(): PureVal;
    function WriteXmlChildStyle(_p1: any; _p2: any);
    function ReadXmlChildDrawing(): Drawing;
    function WriteXmlChildDrawing(_p1: any; _p2: any);

public
    // Attributes
    XmlAttrRequires: OpenXmlAttribute;

    // Children
    XmlChildStyle: PureVal;
    XmlChildDrawing: Drawing;
end;

type Fallback = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Fallback);override;
    function ConvertToPoint();override;

public

    // normal property
    property Style read ReadXmlChildStyle write WriteXmlChildStyle;
    property Pict read ReadXmlChildPict write WriteXmlChildPict;
    function ReadXmlChildStyle(): PureVal;
    function WriteXmlChildStyle(_p1: any; _p2: any);
    function ReadXmlChildPict(): Pict;
    function WriteXmlChildPict(_p1: any; _p2: any);

public
    // Children
    XmlChildStyle: PureVal;
    XmlChildPict: Pict;
end;

type Pict = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Pict);override;
    function ConvertToPoint();override;

public

    // normal property
    property Shapetype read ReadXmlChildShapetype write WriteXmlChildShapetype;
    property Shape read ReadXmlChildShape write WriteXmlChildShape;
    property Control read ReadXmlChildControl write WriteXmlChildControl;
    function ReadXmlChildShapetype(): Shapetype;
    function WriteXmlChildShapetype(_p1: any; _p2: any);
    function ReadXmlChildShape(): Shape;
    function WriteXmlChildShape(_p1: any; _p2: any);
    function ReadXmlChildControl(): Control;
    function WriteXmlChildControl(_p1: any; _p2: any);

public
    // Children
    XmlChildShapetype: Shapetype;
    XmlChildShape: Shape;
    XmlChildControl: Control;
end;

type Control = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Control);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Id read ReadXmlAttrId write WriteXmlAttrId;
    property Shapeid read ReadXmlAttrShapeid write WriteXmlAttrShapeid;
    property name read ReadXmlAttrname write WriteXmlAttrname;
    function ReadXmlAttrId();
    function WriteXmlAttrId(_value: any);
    function ReadXmlAttrShapeid();
    function WriteXmlAttrShapeid(_value: any);
    function ReadXmlAttrname();
    function WriteXmlAttrname(_value: any);

public
    // Attributes
    XmlAttrId: OpenXmlAttribute;
    XmlAttrShapeid: OpenXmlAttribute;
    XmlAttrname: OpenXmlAttribute;

end;

type Ftr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Ftr);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Ignorable read ReadXmlAttrIgnorable write WriteXmlAttrIgnorable;
    function ReadXmlAttrIgnorable();
    function WriteXmlAttrIgnorable(_value: any);

    // normal property
    property Sdt read ReadXmlChildSdt write WriteXmlChildSdt;
    function ReadXmlChildSdt(): Sdt;
    function WriteXmlChildSdt(_p1: any; _p2: any);

    // multi property
    property Ps read ReadPs write WritePs;
    function ReadPs(_index: integer);
    function WritePs(_index: integer; _value: nil_OR_P);
    function AddP(): P;
    function AppendP(): P;

public
    // Attributes
    XmlAttrIgnorable: OpenXmlAttribute;

    // Children
    XmlChildSdt: Sdt;
end;

type Hdr = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Hdr);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Ignorable read ReadXmlAttrIgnorable write WriteXmlAttrIgnorable;
    function ReadXmlAttrIgnorable();
    function WriteXmlAttrIgnorable(_value: any);

    // normal property
    property Sdt read ReadXmlChildSdt write WriteXmlChildSdt;
    function ReadXmlChildSdt(): Sdt;
    function WriteXmlChildSdt(_p1: any; _p2: any);

    // multi property
    property Ps read ReadPs write WritePs;
    function ReadPs(_index: integer);
    function WritePs(_index: integer; _value: nil_OR_P);
    function AddP(): P;
    function AppendP(): P;

public
    // Attributes
    XmlAttrIgnorable: OpenXmlAttribute;

    // Children
    XmlChildSdt: Sdt;
end;

type Comments = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Comments);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Ignorable read ReadXmlAttrIgnorable write WriteXmlAttrIgnorable;
    function ReadXmlAttrIgnorable();
    function WriteXmlAttrIgnorable(_value: any);

    // multi property
    property Comments read ReadComments write WriteComments;
    function ReadComments(_index: integer);
    function WriteComments(_index: integer; _value: nil_OR_Comment);
    function AddComment(): Comment;
    function AppendComment(): Comment;

public
    // Attributes
    XmlAttrIgnorable: OpenXmlAttribute;

    // Children
end;

type Comment = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Comment);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Author read ReadXmlAttrAuthor write WriteXmlAttrAuthor;
    property Date read ReadXmlAttrDate write WriteXmlAttrDate;
    property Id read ReadXmlAttrId write WriteXmlAttrId;
    function ReadXmlAttrAuthor();
    function WriteXmlAttrAuthor(_value: any);
    function ReadXmlAttrDate();
    function WriteXmlAttrDate(_value: any);
    function ReadXmlAttrId();
    function WriteXmlAttrId(_value: any);

    // multi property
    property Ps read ReadPs write WritePs;
    function ReadPs(_index: integer);
    function WritePs(_index: integer; _value: nil_OR_P);
    function AddP(): P;
    function AppendP(): P;

public
    // Attributes
    XmlAttrAuthor: OpenXmlAttribute;
    XmlAttrDate: OpenXmlAttribute;
    XmlAttrId: OpenXmlAttribute;

    // Children
end;

type Numbering = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Numbering);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Ignorable read ReadXmlAttrIgnorable write WriteXmlAttrIgnorable;
    function ReadXmlAttrIgnorable();
    function WriteXmlAttrIgnorable(_value: any);

    // multi property
    property AbstractNums read ReadAbstractNums write WriteAbstractNums;
    property Nums read ReadNums write WriteNums;
    function ReadAbstractNums(_index: integer);
    function WriteAbstractNums(_index: integer; _value: nil_OR_AbstractNum);
    function ReadNums(_index: integer);
    function WriteNums(_index: integer; _value: nil_OR_Num);
    function AddAbstractNum(): AbstractNum;
    function AddNum(): Num;
    function AppendAbstractNum(): AbstractNum;
    function AppendNum(): Num;

public
    // Attributes
    XmlAttrIgnorable: OpenXmlAttribute;

    // Children
end;

type Num = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Num);override;
    function ConvertToPoint();override;

public
    // attributes property
    property NumId read ReadXmlAttrNumId write WriteXmlAttrNumId;
    function ReadXmlAttrNumId();
    function WriteXmlAttrNumId(_value: any);

    // normal property
    property AbstractNumId read ReadXmlChildAbstractNumId write WriteXmlChildAbstractNumId;
    function ReadXmlChildAbstractNumId(): PureWVal;
    function WriteXmlChildAbstractNumId(_p1: any; _p2: any);

public
    // Attributes
    XmlAttrNumId: OpenXmlAttribute;

    // Children
    XmlChildAbstractNumId: PureWVal;
end;

type AbstractNum = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: AbstractNum);override;
    function ConvertToPoint();override;

public
    // attributes property
    property AbstractNumId read ReadXmlAttrAbstractNumId write WriteXmlAttrAbstractNumId;
    property RestartNumberingAfterBreak read ReadXmlAttrRestartNumberingAfterBreak write WriteXmlAttrRestartNumberingAfterBreak;
    function ReadXmlAttrAbstractNumId();
    function WriteXmlAttrAbstractNumId(_value: any);
    function ReadXmlAttrRestartNumberingAfterBreak();
    function WriteXmlAttrRestartNumberingAfterBreak(_value: any);

    // normal property
    property Nsid read ReadXmlChildNsid write WriteXmlChildNsid;
    property MultiLevelType read ReadXmlChildMultiLevelType write WriteXmlChildMultiLevelType;
    property Tmpl read ReadXmlChildTmpl write WriteXmlChildTmpl;
    function ReadXmlChildNsid(): PureWVal;
    function WriteXmlChildNsid(_p1: any; _p2: any);
    function ReadXmlChildMultiLevelType(): PureWVal;
    function WriteXmlChildMultiLevelType(_p1: any; _p2: any);
    function ReadXmlChildTmpl(): PureWVal;
    function WriteXmlChildTmpl(_p1: any; _p2: any);

    // multi property
    property Lvls read ReadLvls write WriteLvls;
    function ReadLvls(_index: integer);
    function WriteLvls(_index: integer; _value: nil_OR_Lvl);
    function AddLvl(): Lvl;
    function AppendLvl(): Lvl;

public
    // Attributes
    XmlAttrAbstractNumId: OpenXmlAttribute;
    XmlAttrRestartNumberingAfterBreak: OpenXmlAttribute;

    // Children
    XmlChildNsid: PureWVal;
    XmlChildMultiLevelType: PureWVal;
    XmlChildTmpl: PureWVal;
end;

type Lvl = class(OpenXmlCompositeElement)
public
    function Create();overload;
    function Create(_node: XmlNode);overload;
    function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
    function Init();override;
    function Copy(_obj: Lvl);override;
    function ConvertToPoint();override;

public
    // attributes property
    property Ilvl read ReadXmlAttrIlvl write WriteXmlAttrIlvl;
    property Tentative read ReadXmlAttrTentative write WriteXmlAttrTentative;
    function ReadXmlAttrIlvl();
    function WriteXmlAttrIlvl(_value: any);
    function ReadXmlAttrTentative();
    function WriteXmlAttrTentative(_value: any);

    // normal property
    property Start read ReadXmlChildStart write WriteXmlChildStart;
    property NumFmt read ReadXmlChildNumFmt write WriteXmlChildNumFmt;
    property PStyle read ReadXmlChildPStyle write WriteXmlChildPStyle;
    property Suff read ReadXmlChildSuff write WriteXmlChildSuff;
    property LvlText read ReadXmlChildLvlText write WriteXmlChildLvlText;
    property LvlJc read ReadXmlChildLvlJc write WriteXmlChildLvlJc;
    property PPr read ReadXmlChildPPr write WriteXmlChildPPr;
    property RPr read ReadXmlChildRPr write WriteXmlChildRPr;
    function ReadXmlChildStart(): PureWVal;
    function WriteXmlChildStart(_p1: any; _p2: any);
    function ReadXmlChildNumFmt(): PureWVal;
    function WriteXmlChildNumFmt(_p1: any; _p2: any);
    function ReadXmlChildPStyle(): PureWVal;
    function WriteXmlChildPStyle(_p1: any; _p2: any);
    function ReadXmlChildSuff(): PureWVal;
    function WriteXmlChildSuff(_p1: any; _p2: any);
    function ReadXmlChildLvlText(): PureWVal;
    function WriteXmlChildLvlText(_p1: any; _p2: any);
    function ReadXmlChildLvlJc(): PureWVal;
    function WriteXmlChildLvlJc(_p1: any; _p2: any);
    function ReadXmlChildPPr(): PPr;
    function WriteXmlChildPPr(_p1: any; _p2: any);
    function ReadXmlChildRPr(): RPr;
    function WriteXmlChildRPr(_p1: any; _p2: any);

public
    // Attributes
    XmlAttrIlvl: OpenXmlAttribute;
    XmlAttrTentative: OpenXmlAttribute;

    // Children
    XmlChildStart: PureWVal;
    XmlChildNumFmt: PureWVal;
    XmlChildPStyle: PureWVal;
    XmlChildSuff: PureWVal;
    XmlChildLvlText: PureWVal;
    XmlChildLvlJc: PureWVal;
    XmlChildPPr: PPr;
    XmlChildRPr: RPr;
end;

implementation

function Properties.Create();overload;
begin
    {self.}Create(nil, "", "Properties");
end;

function Properties.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Properties.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Properties.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        "Template": array(0, makeweakref(thisFunction(ReadXmlChildTemplate))),
        "TotalTime": array(1, makeweakref(thisFunction(ReadXmlChildTotalTime))),
        "Pages": array(2, makeweakref(thisFunction(ReadXmlChildPages))),
        "Words": array(3, makeweakref(thisFunction(ReadXmlChildWords))),
        "Characters": array(4, makeweakref(thisFunction(ReadXmlChildCharacters))),
        "Application": array(5, makeweakref(thisFunction(ReadXmlChildApplication))),
        "DocSecurity": array(6, makeweakref(thisFunction(ReadXmlChildDocSecurity))),
        "Lines": array(7, makeweakref(thisFunction(ReadXmlChildLines))),
        "Paragraphs": array(8, makeweakref(thisFunction(ReadXmlChildParagraphs))),
        "ScaleCrop": array(9, makeweakref(thisFunction(ReadXmlChildScaleCrop))),
        "Company": array(10, makeweakref(thisFunction(ReadXmlChildCompany))),
        "LinksUpToDate": array(11, makeweakref(thisFunction(ReadXmlChildLinksUpToDate))),
        "charactersWithSpaces": array(12, makeweakref(thisFunction(ReadXmlChildCharactersWithSpaces))),
        "SharedDoc": array(13, makeweakref(thisFunction(ReadXmlChildSharedDoc))),
        "HyperlinksChanged": array(14, makeweakref(thisFunction(ReadXmlChildHyperlinksChanged))),
        "AppVersion": array(15, makeweakref(thisFunction(ReadXmlChildAppVersion))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Properties.Copy(_obj: Properties);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildTemplate) then
        {self.}Template.Copy(_obj.XmlChildTemplate);
    if not ifnil(_obj.XmlChildTotalTime) then
        {self.}TotalTime.Copy(_obj.XmlChildTotalTime);
    if not ifnil(_obj.XmlChildPages) then
        {self.}Pages.Copy(_obj.XmlChildPages);
    if not ifnil(_obj.XmlChildWords) then
        {self.}Words.Copy(_obj.XmlChildWords);
    if not ifnil(_obj.XmlChildCharacters) then
        {self.}Characters.Copy(_obj.XmlChildCharacters);
    if not ifnil(_obj.XmlChildApplication) then
        {self.}Application.Copy(_obj.XmlChildApplication);
    if not ifnil(_obj.XmlChildDocSecurity) then
        {self.}DocSecurity.Copy(_obj.XmlChildDocSecurity);
    if not ifnil(_obj.XmlChildLines) then
        {self.}Lines.Copy(_obj.XmlChildLines);
    if not ifnil(_obj.XmlChildParagraphs) then
        {self.}Paragraphs.Copy(_obj.XmlChildParagraphs);
    if not ifnil(_obj.XmlChildScaleCrop) then
        {self.}ScaleCrop.Copy(_obj.XmlChildScaleCrop);
    if not ifnil(_obj.XmlChildCompany) then
        {self.}Company.Copy(_obj.XmlChildCompany);
    if not ifnil(_obj.XmlChildLinksUpToDate) then
        {self.}LinksUpToDate.Copy(_obj.XmlChildLinksUpToDate);
    if not ifnil(_obj.XmlChildCharactersWithSpaces) then
        {self.}CharactersWithSpaces.Copy(_obj.XmlChildCharactersWithSpaces);
    if not ifnil(_obj.XmlChildSharedDoc) then
        {self.}SharedDoc.Copy(_obj.XmlChildSharedDoc);
    if not ifnil(_obj.XmlChildHyperlinksChanged) then
        {self.}HyperlinksChanged.Copy(_obj.XmlChildHyperlinksChanged);
    if not ifnil(_obj.XmlChildAppVersion) then
        {self.}AppVersion.Copy(_obj.XmlChildAppVersion);
    tslassigning := tslassigning_backup;
end;

function Properties.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildTemplate) then
    if not ifnil({self.}XmlChildTotalTime) then
    if not ifnil({self.}XmlChildPages) then
    if not ifnil({self.}XmlChildWords) then
    if not ifnil({self.}XmlChildCharacters) then
    if not ifnil({self.}XmlChildApplication) then
    if not ifnil({self.}XmlChildDocSecurity) then
    if not ifnil({self.}XmlChildLines) then
    if not ifnil({self.}XmlChildParagraphs) then
    if not ifnil({self.}XmlChildScaleCrop) then
    if not ifnil({self.}XmlChildCompany) then
    if not ifnil({self.}XmlChildLinksUpToDate) then
    if not ifnil({self.}XmlChildCharactersWithSpaces) then
    if not ifnil({self.}XmlChildSharedDoc) then
    if not ifnil({self.}XmlChildHyperlinksChanged) then
    if not ifnil({self.}XmlChildAppVersion) then
end;

function Properties.ReadXmlChildTemplate();
begin
    if tslassigning and (ifnil({self.}XmlChildTemplate) or {self.}XmlChildTemplate.Removed) then
    begin
        {self.}XmlChildTemplate := new OpenXmlTextElement(self, "", "Template");
        container_.Set({self.}XmlChildTemplate);
    end
    return {self.}XmlChildTemplate and not {self.}XmlChildTemplate.Removed ? {self.}XmlChildTemplate : fallback_.XmlChildTemplate;
end;

function Properties.WriteXmlChildTemplate(_value: nil_or_OpenXmlTextElement);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildTemplate) then
            {self.}RemoveChild({self.}XmlChildTemplate);
    end
    else if _value is class(OpenXmlTextElement) then
    begin
        {self.}XmlChildTemplate := _value;
        container_.Set({self.}XmlChildTemplate);
    end
    else begin
        raise "Invalid assignment: Template expects nil or OpenXmlTextElement";
    end
end;

function Properties.ReadXmlChildTotalTime();
begin
    if tslassigning and (ifnil({self.}XmlChildTotalTime) or {self.}XmlChildTotalTime.Removed) then
    begin
        {self.}XmlChildTotalTime := new OpenXmlTextElement(self, "", "TotalTime");
        container_.Set({self.}XmlChildTotalTime);
    end
    return {self.}XmlChildTotalTime and not {self.}XmlChildTotalTime.Removed ? {self.}XmlChildTotalTime : fallback_.XmlChildTotalTime;
end;

function Properties.WriteXmlChildTotalTime(_value: nil_or_OpenXmlTextElement);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildTotalTime) then
            {self.}RemoveChild({self.}XmlChildTotalTime);
    end
    else if _value is class(OpenXmlTextElement) then
    begin
        {self.}XmlChildTotalTime := _value;
        container_.Set({self.}XmlChildTotalTime);
    end
    else begin
        raise "Invalid assignment: TotalTime expects nil or OpenXmlTextElement";
    end
end;

function Properties.ReadXmlChildPages();
begin
    if tslassigning and (ifnil({self.}XmlChildPages) or {self.}XmlChildPages.Removed) then
    begin
        {self.}XmlChildPages := new OpenXmlTextElement(self, "", "Pages");
        container_.Set({self.}XmlChildPages);
    end
    return {self.}XmlChildPages and not {self.}XmlChildPages.Removed ? {self.}XmlChildPages : fallback_.XmlChildPages;
end;

function Properties.WriteXmlChildPages(_value: nil_or_OpenXmlTextElement);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildPages) then
            {self.}RemoveChild({self.}XmlChildPages);
    end
    else if _value is class(OpenXmlTextElement) then
    begin
        {self.}XmlChildPages := _value;
        container_.Set({self.}XmlChildPages);
    end
    else begin
        raise "Invalid assignment: Pages expects nil or OpenXmlTextElement";
    end
end;

function Properties.ReadXmlChildWords();
begin
    if tslassigning and (ifnil({self.}XmlChildWords) or {self.}XmlChildWords.Removed) then
    begin
        {self.}XmlChildWords := new OpenXmlTextElement(self, "", "Words");
        container_.Set({self.}XmlChildWords);
    end
    return {self.}XmlChildWords and not {self.}XmlChildWords.Removed ? {self.}XmlChildWords : fallback_.XmlChildWords;
end;

function Properties.WriteXmlChildWords(_value: nil_or_OpenXmlTextElement);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildWords) then
            {self.}RemoveChild({self.}XmlChildWords);
    end
    else if _value is class(OpenXmlTextElement) then
    begin
        {self.}XmlChildWords := _value;
        container_.Set({self.}XmlChildWords);
    end
    else begin
        raise "Invalid assignment: Words expects nil or OpenXmlTextElement";
    end
end;

function Properties.ReadXmlChildCharacters();
begin
    if tslassigning and (ifnil({self.}XmlChildCharacters) or {self.}XmlChildCharacters.Removed) then
    begin
        {self.}XmlChildCharacters := new OpenXmlTextElement(self, "", "Characters");
        container_.Set({self.}XmlChildCharacters);
    end
    return {self.}XmlChildCharacters and not {self.}XmlChildCharacters.Removed ? {self.}XmlChildCharacters : fallback_.XmlChildCharacters;
end;

function Properties.WriteXmlChildCharacters(_value: nil_or_OpenXmlTextElement);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildCharacters) then
            {self.}RemoveChild({self.}XmlChildCharacters);
    end
    else if _value is class(OpenXmlTextElement) then
    begin
        {self.}XmlChildCharacters := _value;
        container_.Set({self.}XmlChildCharacters);
    end
    else begin
        raise "Invalid assignment: Characters expects nil or OpenXmlTextElement";
    end
end;

function Properties.ReadXmlChildApplication();
begin
    if tslassigning and (ifnil({self.}XmlChildApplication) or {self.}XmlChildApplication.Removed) then
    begin
        {self.}XmlChildApplication := new OpenXmlTextElement(self, "", "Application");
        container_.Set({self.}XmlChildApplication);
    end
    return {self.}XmlChildApplication and not {self.}XmlChildApplication.Removed ? {self.}XmlChildApplication : fallback_.XmlChildApplication;
end;

function Properties.WriteXmlChildApplication(_value: nil_or_OpenXmlTextElement);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildApplication) then
            {self.}RemoveChild({self.}XmlChildApplication);
    end
    else if _value is class(OpenXmlTextElement) then
    begin
        {self.}XmlChildApplication := _value;
        container_.Set({self.}XmlChildApplication);
    end
    else begin
        raise "Invalid assignment: Application expects nil or OpenXmlTextElement";
    end
end;

function Properties.ReadXmlChildDocSecurity();
begin
    if tslassigning and (ifnil({self.}XmlChildDocSecurity) or {self.}XmlChildDocSecurity.Removed) then
    begin
        {self.}XmlChildDocSecurity := new OpenXmlTextElement(self, "", "DocSecurity");
        container_.Set({self.}XmlChildDocSecurity);
    end
    return {self.}XmlChildDocSecurity and not {self.}XmlChildDocSecurity.Removed ? {self.}XmlChildDocSecurity : fallback_.XmlChildDocSecurity;
end;

function Properties.WriteXmlChildDocSecurity(_value: nil_or_OpenXmlTextElement);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildDocSecurity) then
            {self.}RemoveChild({self.}XmlChildDocSecurity);
    end
    else if _value is class(OpenXmlTextElement) then
    begin
        {self.}XmlChildDocSecurity := _value;
        container_.Set({self.}XmlChildDocSecurity);
    end
    else begin
        raise "Invalid assignment: DocSecurity expects nil or OpenXmlTextElement";
    end
end;

function Properties.ReadXmlChildLines();
begin
    if tslassigning and (ifnil({self.}XmlChildLines) or {self.}XmlChildLines.Removed) then
    begin
        {self.}XmlChildLines := new OpenXmlTextElement(self, "", "Lines");
        container_.Set({self.}XmlChildLines);
    end
    return {self.}XmlChildLines and not {self.}XmlChildLines.Removed ? {self.}XmlChildLines : fallback_.XmlChildLines;
end;

function Properties.WriteXmlChildLines(_value: nil_or_OpenXmlTextElement);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildLines) then
            {self.}RemoveChild({self.}XmlChildLines);
    end
    else if _value is class(OpenXmlTextElement) then
    begin
        {self.}XmlChildLines := _value;
        container_.Set({self.}XmlChildLines);
    end
    else begin
        raise "Invalid assignment: Lines expects nil or OpenXmlTextElement";
    end
end;

function Properties.ReadXmlChildParagraphs();
begin
    if tslassigning and (ifnil({self.}XmlChildParagraphs) or {self.}XmlChildParagraphs.Removed) then
    begin
        {self.}XmlChildParagraphs := new OpenXmlTextElement(self, "", "Paragraphs");
        container_.Set({self.}XmlChildParagraphs);
    end
    return {self.}XmlChildParagraphs and not {self.}XmlChildParagraphs.Removed ? {self.}XmlChildParagraphs : fallback_.XmlChildParagraphs;
end;

function Properties.WriteXmlChildParagraphs(_value: nil_or_OpenXmlTextElement);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildParagraphs) then
            {self.}RemoveChild({self.}XmlChildParagraphs);
    end
    else if _value is class(OpenXmlTextElement) then
    begin
        {self.}XmlChildParagraphs := _value;
        container_.Set({self.}XmlChildParagraphs);
    end
    else begin
        raise "Invalid assignment: Paragraphs expects nil or OpenXmlTextElement";
    end
end;

function Properties.ReadXmlChildScaleCrop();
begin
    if tslassigning and (ifnil({self.}XmlChildScaleCrop) or {self.}XmlChildScaleCrop.Removed) then
    begin
        {self.}XmlChildScaleCrop := new OpenXmlTextElement(self, "", "ScaleCrop");
        container_.Set({self.}XmlChildScaleCrop);
    end
    return {self.}XmlChildScaleCrop and not {self.}XmlChildScaleCrop.Removed ? {self.}XmlChildScaleCrop : fallback_.XmlChildScaleCrop;
end;

function Properties.WriteXmlChildScaleCrop(_value: nil_or_OpenXmlTextElement);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildScaleCrop) then
            {self.}RemoveChild({self.}XmlChildScaleCrop);
    end
    else if _value is class(OpenXmlTextElement) then
    begin
        {self.}XmlChildScaleCrop := _value;
        container_.Set({self.}XmlChildScaleCrop);
    end
    else begin
        raise "Invalid assignment: ScaleCrop expects nil or OpenXmlTextElement";
    end
end;

function Properties.ReadXmlChildCompany();
begin
    if tslassigning and (ifnil({self.}XmlChildCompany) or {self.}XmlChildCompany.Removed) then
    begin
        {self.}XmlChildCompany := new OpenXmlTextElement(self, "", "Company");
        container_.Set({self.}XmlChildCompany);
    end
    return {self.}XmlChildCompany and not {self.}XmlChildCompany.Removed ? {self.}XmlChildCompany : fallback_.XmlChildCompany;
end;

function Properties.WriteXmlChildCompany(_value: nil_or_OpenXmlTextElement);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildCompany) then
            {self.}RemoveChild({self.}XmlChildCompany);
    end
    else if _value is class(OpenXmlTextElement) then
    begin
        {self.}XmlChildCompany := _value;
        container_.Set({self.}XmlChildCompany);
    end
    else begin
        raise "Invalid assignment: Company expects nil or OpenXmlTextElement";
    end
end;

function Properties.ReadXmlChildLinksUpToDate();
begin
    if tslassigning and (ifnil({self.}XmlChildLinksUpToDate) or {self.}XmlChildLinksUpToDate.Removed) then
    begin
        {self.}XmlChildLinksUpToDate := new OpenXmlTextElement(self, "", "LinksUpToDate");
        container_.Set({self.}XmlChildLinksUpToDate);
    end
    return {self.}XmlChildLinksUpToDate and not {self.}XmlChildLinksUpToDate.Removed ? {self.}XmlChildLinksUpToDate : fallback_.XmlChildLinksUpToDate;
end;

function Properties.WriteXmlChildLinksUpToDate(_value: nil_or_OpenXmlTextElement);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildLinksUpToDate) then
            {self.}RemoveChild({self.}XmlChildLinksUpToDate);
    end
    else if _value is class(OpenXmlTextElement) then
    begin
        {self.}XmlChildLinksUpToDate := _value;
        container_.Set({self.}XmlChildLinksUpToDate);
    end
    else begin
        raise "Invalid assignment: LinksUpToDate expects nil or OpenXmlTextElement";
    end
end;

function Properties.ReadXmlChildCharactersWithSpaces();
begin
    if tslassigning and (ifnil({self.}XmlChildCharactersWithSpaces) or {self.}XmlChildCharactersWithSpaces.Removed) then
    begin
        {self.}XmlChildCharactersWithSpaces := new OpenXmlTextElement(self, "", "charactersWithSpaces");
        container_.Set({self.}XmlChildCharactersWithSpaces);
    end
    return {self.}XmlChildCharactersWithSpaces and not {self.}XmlChildCharactersWithSpaces.Removed ? {self.}XmlChildCharactersWithSpaces : fallback_.XmlChildCharactersWithSpaces;
end;

function Properties.WriteXmlChildCharactersWithSpaces(_value: nil_or_OpenXmlTextElement);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildCharactersWithSpaces) then
            {self.}RemoveChild({self.}XmlChildCharactersWithSpaces);
    end
    else if _value is class(OpenXmlTextElement) then
    begin
        {self.}XmlChildCharactersWithSpaces := _value;
        container_.Set({self.}XmlChildCharactersWithSpaces);
    end
    else begin
        raise "Invalid assignment: CharactersWithSpaces expects nil or OpenXmlTextElement";
    end
end;

function Properties.ReadXmlChildSharedDoc();
begin
    if tslassigning and (ifnil({self.}XmlChildSharedDoc) or {self.}XmlChildSharedDoc.Removed) then
    begin
        {self.}XmlChildSharedDoc := new OpenXmlTextElement(self, "", "SharedDoc");
        container_.Set({self.}XmlChildSharedDoc);
    end
    return {self.}XmlChildSharedDoc and not {self.}XmlChildSharedDoc.Removed ? {self.}XmlChildSharedDoc : fallback_.XmlChildSharedDoc;
end;

function Properties.WriteXmlChildSharedDoc(_value: nil_or_OpenXmlTextElement);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildSharedDoc) then
            {self.}RemoveChild({self.}XmlChildSharedDoc);
    end
    else if _value is class(OpenXmlTextElement) then
    begin
        {self.}XmlChildSharedDoc := _value;
        container_.Set({self.}XmlChildSharedDoc);
    end
    else begin
        raise "Invalid assignment: SharedDoc expects nil or OpenXmlTextElement";
    end
end;

function Properties.ReadXmlChildHyperlinksChanged();
begin
    if tslassigning and (ifnil({self.}XmlChildHyperlinksChanged) or {self.}XmlChildHyperlinksChanged.Removed) then
    begin
        {self.}XmlChildHyperlinksChanged := new OpenXmlTextElement(self, "", "HyperlinksChanged");
        container_.Set({self.}XmlChildHyperlinksChanged);
    end
    return {self.}XmlChildHyperlinksChanged and not {self.}XmlChildHyperlinksChanged.Removed ? {self.}XmlChildHyperlinksChanged : fallback_.XmlChildHyperlinksChanged;
end;

function Properties.WriteXmlChildHyperlinksChanged(_value: nil_or_OpenXmlTextElement);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildHyperlinksChanged) then
            {self.}RemoveChild({self.}XmlChildHyperlinksChanged);
    end
    else if _value is class(OpenXmlTextElement) then
    begin
        {self.}XmlChildHyperlinksChanged := _value;
        container_.Set({self.}XmlChildHyperlinksChanged);
    end
    else begin
        raise "Invalid assignment: HyperlinksChanged expects nil or OpenXmlTextElement";
    end
end;

function Properties.ReadXmlChildAppVersion();
begin
    if tslassigning and (ifnil({self.}XmlChildAppVersion) or {self.}XmlChildAppVersion.Removed) then
    begin
        {self.}XmlChildAppVersion := new OpenXmlTextElement(self, "", "AppVersion");
        container_.Set({self.}XmlChildAppVersion);
    end
    return {self.}XmlChildAppVersion and not {self.}XmlChildAppVersion.Removed ? {self.}XmlChildAppVersion : fallback_.XmlChildAppVersion;
end;

function Properties.WriteXmlChildAppVersion(_value: nil_or_OpenXmlTextElement);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildAppVersion) then
            {self.}RemoveChild({self.}XmlChildAppVersion);
    end
    else if _value is class(OpenXmlTextElement) then
    begin
        {self.}XmlChildAppVersion := _value;
        container_.Set({self.}XmlChildAppVersion);
    end
    else begin
        raise "Invalid assignment: AppVersion expects nil or OpenXmlTextElement";
    end
end;

function Document.Create();overload;
begin
    {self.}Create(nil, "w", "document");
end;

function Document.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Document.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Document.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "mc:Ignorable": makeweakref(thisFunction(WriteXmlAttrIgnorable)),
    );
    sorted_child_ := array(
        pre + "body": array(0, makeweakref(thisFunction(ReadXmlChildBody))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Document.Copy(_obj: Document);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Ignorable) then
        {self.}Ignorable := _obj.Ignorable;
    if not ifnil(_obj.XmlChildBody) then
        {self.}Body.Copy(_obj.XmlChildBody);
    tslassigning := tslassigning_backup;
end;

function Document.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildBody) then
        {self.}XmlChildBody.ConvertToPoint();
end;

function Document.ReadXmlAttrIgnorable();
begin
    return ifnil({self.}XmlAttrIgnorable.Value) ? fallback_.XmlAttrIgnorable.Value : {self.}XmlAttrIgnorable.Value;
end;

function Document.WriteXmlAttrIgnorable(_value: any);
begin
    if ifnil({self.}XmlAttrIgnorable) then
    begin
        {self.}XmlAttrIgnorable := new OpenXmlAttribute("mc", "Ignorable", nil);
        attributes_["mc:Ignorable"] := {self.}XmlAttrIgnorable;
    end
    {self.}XmlAttrIgnorable.Value := _value;
end;

function Document.ReadXmlChildBody(): Body;
begin
    if tslassigning and (ifnil({self.}XmlChildBody) or {self.}XmlChildBody.Removed) then
    begin
        {self.}XmlChildBody := new Body(self, {self.}Prefix, "body");
        container_.Set({self.}XmlChildBody);
    end
    return {self.}XmlChildBody and not {self.}XmlChildBody.Removed ? {self.}XmlChildBody : fallback_.XmlChildBody;
end;

function Document.WriteXmlChildBody(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildBody) then
            {self.}RemoveChild({self.}XmlChildBody);
    end
    else if v is class(Body) then
    begin
        {self.}XmlChildBody := v;
        container_.Set({self.}XmlChildBody);
    end
    else begin
        raise "Invalid assignment: Body expects Body or nil";
    end
end;

function Body.Create();overload;
begin
    {self.}Create(nil, "w", "body");
end;

function Body.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Body.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Body.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "p": array(0, makeweakref(thisFunction(AppendP))),
        pre + "tbl": array(1, makeweakref(thisFunction(AppendTbl))),
        pre + "sdt": array(2, makeweakref(thisFunction(AppendSdt))),
        pre + "sectPr": array(-1, makeweakref(thisFunction(ReadXmlChildSectPr))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Body.Copy(_obj: Body);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildSectPr) then
        {self.}SectPr.Copy(_obj.XmlChildSectPr);
    tslassigning := tslassigning_backup;
end;

function Body.ConvertToPoint();override;
begin
    elems := {self.}Ps();
    for _,elem in elems do
        elem.ConvertToPoint();
    elems := {self.}Tbls();
    for _,elem in elems do
        elem.ConvertToPoint();
    elems := {self.}Sdts();
    for _,elem in elems do
        elem.ConvertToPoint();
    if not ifnil({self.}XmlChildSectPr) then
        {self.}XmlChildSectPr.ConvertToPoint();
end;

function Body.ReadXmlChildSectPr(): SectPr;
begin
    if tslassigning and (ifnil({self.}XmlChildSectPr) or {self.}XmlChildSectPr.Removed) then
    begin
        {self.}XmlChildSectPr := new SectPr(self, {self.}Prefix, "sectPr");
        container_.Append({self.}XmlChildSectPr);
    end
    return {self.}XmlChildSectPr and not {self.}XmlChildSectPr.Removed ? {self.}XmlChildSectPr : fallback_.XmlChildSectPr;
end;

function Body.WriteXmlChildSectPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildSectPr) then
            {self.}RemoveChild({self.}XmlChildSectPr);
    end
    else if v is class(SectPr) then
    begin
        {self.}XmlChildSectPr := v;
        container_.Set({self.}XmlChildSectPr);
    end
    else begin
        raise "Invalid assignment: SectPr expects SectPr or nil";
    end
end;

function Body.ReadPs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "p", ind);
end;

function Body.WritePs(_index: integer; _value: nil_OR_P);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadPs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "p", ind, _value) then
            raise format("Index out of range: Ps[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Ps expects nil or P";
    end
end;

function Body.ReadTbls(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "tbl", ind);
end;

function Body.WriteTbls(_index: integer; _value: nil_OR_Tbl);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadTbls(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "tbl", ind, _value) then
            raise format("Index out of range: Tbls[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Tbls expects nil or Tbl";
    end
end;

function Body.ReadSdts(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "sdt", ind);
end;

function Body.WriteSdts(_index: integer; _value: nil_OR_Sdt);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadSdts(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "sdt", ind, _value) then
            raise format("Index out of range: Sdts[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Sdts expects nil or Sdt";
    end
end;

function Body.AddP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Insert(obj);
    return obj;
end;

function Body.AddTbl(): Tbl;
begin
    obj := new Tbl(self, {self.}Prefix, "tbl");
    container_.Insert(obj);
    return obj;
end;

function Body.AddSdt(): Sdt;
begin
    obj := new Sdt(self, {self.}Prefix, "sdt");
    container_.Insert(obj);
    return obj;
end;

function Body.AppendP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Append(obj);
    return obj;
end;

function Body.AppendTbl(): Tbl;
begin
    obj := new Tbl(self, {self.}Prefix, "tbl");
    container_.Append(obj);
    return obj;
end;

function Body.AppendSdt(): Sdt;
begin
    obj := new Sdt(self, {self.}Prefix, "sdt");
    container_.Append(obj);
    return obj;
end;

function P.Create();overload;
begin
    {self.}Create(nil, "w", "p");
end;

function P.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function P.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function P.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "w14:paraId": makeweakref(thisFunction(WriteXmlAttrParaId)),
        "w14:textId": makeweakref(thisFunction(WriteXmlAttrTextId)),
        pre + "rsidR": makeweakref(thisFunction(WriteXmlAttrRsidR)),
        pre + "rsidRPr": makeweakref(thisFunction(WriteXmlAttrRsidRPr)),
        pre + "rsidRDefault": makeweakref(thisFunction(WriteXmlAttrRsidRDefault)),
        pre + "rsidP": makeweakref(thisFunction(WriteXmlAttrRsidP)),
    );
    sorted_child_ := array(
        pre + "pPr": array(0, makeweakref(thisFunction(ReadXmlChildPPr))),
        pre + "sdt": array(1, makeweakref(thisFunction(AppendSdt))),
        pre + "r": array(2, makeweakref(thisFunction(AppendR))),
        pre + "commentRangeStart": array(3, makeweakref(thisFunction(AppendCommentRangeStart))),
        pre + "commentRangeEnd": array(4, makeweakref(thisFunction(AppendCommentRangeEnd))),
        pre + "bookmarkStart": array(5, makeweakref(thisFunction(AppendBookmarkStart))),
        pre + "bookmarkEnd": array(6, makeweakref(thisFunction(AppendBookmarkEnd))),
        pre + "hyperlink": array(7, makeweakref(thisFunction(AppendHyperLink))),
        pre + "fldSimple": array(8, makeweakref(thisFunction(AppendFldSimple))),
        "m:oMathPara": array(9, makeweakref(thisFunction(ReadXmlChildOMathPara))),
        "m:oMath": array(10, makeweakref(thisFunction(ReadXmlChildOMath))),
        pre + "ins": array(11, makeweakref(thisFunction(ReadXmlChildIns))),
        pre + "del": array(12, makeweakref(thisFunction(ReadXmlChildDel))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function P.Copy(_obj: P);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.ParaId) then
        {self.}ParaId := _obj.ParaId;
    if not ifnil(_obj.TextId) then
        {self.}TextId := _obj.TextId;
    if not ifnil(_obj.RsidR) then
        {self.}RsidR := _obj.RsidR;
    if not ifnil(_obj.RsidRPr) then
        {self.}RsidRPr := _obj.RsidRPr;
    if not ifnil(_obj.RsidRDefault) then
        {self.}RsidRDefault := _obj.RsidRDefault;
    if not ifnil(_obj.RsidP) then
        {self.}RsidP := _obj.RsidP;
    if not ifnil(_obj.XmlChildPPr) then
        {self.}PPr.Copy(_obj.XmlChildPPr);
    if not ifnil(_obj.XmlChildOMathPara) then
        {self.}OMathPara.Copy(_obj.XmlChildOMathPara);
    if not ifnil(_obj.XmlChildOMath) then
        {self.}OMath.Copy(_obj.XmlChildOMath);
    if not ifnil(_obj.XmlChildIns) then
        {self.}Ins.Copy(_obj.XmlChildIns);
    if not ifnil(_obj.XmlChildDel) then
        {self.}Del.Copy(_obj.XmlChildDel);
    tslassigning := tslassigning_backup;
end;

function P.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildPPr) then
        {self.}XmlChildPPr.ConvertToPoint();
    elems := {self.}Sdts();
    for _,elem in elems do
        elem.ConvertToPoint();
    elems := {self.}Rs();
    for _,elem in elems do
        elem.ConvertToPoint();
    elems := {self.}CommentRangeStarts();
    for _,elem in elems do
        elem.ConvertToPoint();
    elems := {self.}CommentRangeEnds();
    for _,elem in elems do
        elem.ConvertToPoint();
    elems := {self.}BookmarkStarts();
    for _,elem in elems do
        elem.ConvertToPoint();
    elems := {self.}BookmarkEnds();
    for _,elem in elems do
        elem.ConvertToPoint();
    elems := {self.}Hyperlinks();
    for _,elem in elems do
        elem.ConvertToPoint();
    elems := {self.}FldSimples();
    for _,elem in elems do
        elem.ConvertToPoint();
    if not ifnil({self.}XmlChildOMathPara) then
        {self.}XmlChildOMathPara.ConvertToPoint();
    if not ifnil({self.}XmlChildOMath) then
        {self.}XmlChildOMath.ConvertToPoint();
    if not ifnil({self.}XmlChildIns) then
        {self.}XmlChildIns.ConvertToPoint();
    if not ifnil({self.}XmlChildDel) then
        {self.}XmlChildDel.ConvertToPoint();
end;

function P.ReadXmlAttrParaId();
begin
    return ifnil({self.}XmlAttrParaId.Value) ? fallback_.XmlAttrParaId.Value : {self.}XmlAttrParaId.Value;
end;

function P.WriteXmlAttrParaId(_value: any);
begin
    if ifnil({self.}XmlAttrParaId) then
    begin
        {self.}XmlAttrParaId := new OpenXmlAttribute("w14", "paraId", nil);
        attributes_["w14:paraId"] := {self.}XmlAttrParaId;
    end
    {self.}XmlAttrParaId.Value := _value;
end;

function P.ReadXmlAttrTextId();
begin
    return ifnil({self.}XmlAttrTextId.Value) ? fallback_.XmlAttrTextId.Value : {self.}XmlAttrTextId.Value;
end;

function P.WriteXmlAttrTextId(_value: any);
begin
    if ifnil({self.}XmlAttrTextId) then
    begin
        {self.}XmlAttrTextId := new OpenXmlAttribute("w14", "textId", nil);
        attributes_["w14:textId"] := {self.}XmlAttrTextId;
    end
    {self.}XmlAttrTextId.Value := _value;
end;

function P.ReadXmlAttrRsidR();
begin
    return ifnil({self.}XmlAttrRsidR.Value) ? fallback_.XmlAttrRsidR.Value : {self.}XmlAttrRsidR.Value;
end;

function P.WriteXmlAttrRsidR(_value: any);
begin
    if ifnil({self.}XmlAttrRsidR) then
    begin
        {self.}XmlAttrRsidR := new OpenXmlAttribute({self.}Prefix, "rsidR", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "rsidR" : "rsidR"] := {self.}XmlAttrRsidR;
    end
    {self.}XmlAttrRsidR.Value := _value;
end;

function P.ReadXmlAttrRsidRPr();
begin
    return ifnil({self.}XmlAttrRsidRPr.Value) ? fallback_.XmlAttrRsidRPr.Value : {self.}XmlAttrRsidRPr.Value;
end;

function P.WriteXmlAttrRsidRPr(_value: any);
begin
    if ifnil({self.}XmlAttrRsidRPr) then
    begin
        {self.}XmlAttrRsidRPr := new OpenXmlAttribute({self.}Prefix, "rsidRPr", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "rsidRPr" : "rsidRPr"] := {self.}XmlAttrRsidRPr;
    end
    {self.}XmlAttrRsidRPr.Value := _value;
end;

function P.ReadXmlAttrRsidRDefault();
begin
    return ifnil({self.}XmlAttrRsidRDefault.Value) ? fallback_.XmlAttrRsidRDefault.Value : {self.}XmlAttrRsidRDefault.Value;
end;

function P.WriteXmlAttrRsidRDefault(_value: any);
begin
    if ifnil({self.}XmlAttrRsidRDefault) then
    begin
        {self.}XmlAttrRsidRDefault := new OpenXmlAttribute({self.}Prefix, "rsidRDefault", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "rsidRDefault" : "rsidRDefault"] := {self.}XmlAttrRsidRDefault;
    end
    {self.}XmlAttrRsidRDefault.Value := _value;
end;

function P.ReadXmlAttrRsidP();
begin
    return ifnil({self.}XmlAttrRsidP.Value) ? fallback_.XmlAttrRsidP.Value : {self.}XmlAttrRsidP.Value;
end;

function P.WriteXmlAttrRsidP(_value: any);
begin
    if ifnil({self.}XmlAttrRsidP) then
    begin
        {self.}XmlAttrRsidP := new OpenXmlAttribute({self.}Prefix, "rsidP", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "rsidP" : "rsidP"] := {self.}XmlAttrRsidP;
    end
    {self.}XmlAttrRsidP.Value := _value;
end;

function P.ReadXmlChildPPr(): PPr;
begin
    if tslassigning and (ifnil({self.}XmlChildPPr) or {self.}XmlChildPPr.Removed) then
    begin
        {self.}XmlChildPPr := new PPr(self, {self.}Prefix, "pPr");
        container_.Set({self.}XmlChildPPr);
    end
    return {self.}XmlChildPPr and not {self.}XmlChildPPr.Removed ? {self.}XmlChildPPr : fallback_.XmlChildPPr;
end;

function P.WriteXmlChildPPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPPr) then
            {self.}RemoveChild({self.}XmlChildPPr);
    end
    else if v is class(PPr) then
    begin
        {self.}XmlChildPPr := v;
        container_.Set({self.}XmlChildPPr);
    end
    else begin
        raise "Invalid assignment: PPr expects PPr or nil";
    end
end;

function P.ReadXmlChildOMathPara(): OMathPara;
begin
    if tslassigning and (ifnil({self.}XmlChildOMathPara) or {self.}XmlChildOMathPara.Removed) then
    begin
        {self.}XmlChildOMathPara := new SharedML.OMathPara(self, "m", "oMathPara");
        container_.Set({self.}XmlChildOMathPara);
    end
    return {self.}XmlChildOMathPara and not {self.}XmlChildOMathPara.Removed ? {self.}XmlChildOMathPara : fallback_.XmlChildOMathPara;
end;

function P.WriteXmlChildOMathPara(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildOMathPara) then
            {self.}RemoveChild({self.}XmlChildOMathPara);
    end
    else if v is class(OMathPara) then
    begin
        {self.}XmlChildOMathPara := v;
        container_.Set({self.}XmlChildOMathPara);
    end
    else begin
        raise "Invalid assignment: OMathPara expects OMathPara or nil";
    end
end;

function P.ReadXmlChildOMath(): OMath;
begin
    if tslassigning and (ifnil({self.}XmlChildOMath) or {self.}XmlChildOMath.Removed) then
    begin
        {self.}XmlChildOMath := new SharedML.OMath(self, "m", "oMath");
        container_.Set({self.}XmlChildOMath);
    end
    return {self.}XmlChildOMath and not {self.}XmlChildOMath.Removed ? {self.}XmlChildOMath : fallback_.XmlChildOMath;
end;

function P.WriteXmlChildOMath(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildOMath) then
            {self.}RemoveChild({self.}XmlChildOMath);
    end
    else if v is class(OMath) then
    begin
        {self.}XmlChildOMath := v;
        container_.Set({self.}XmlChildOMath);
    end
    else begin
        raise "Invalid assignment: OMath expects OMath or nil";
    end
end;

function P.ReadXmlChildIns(): Ins;
begin
    if tslassigning and (ifnil({self.}XmlChildIns) or {self.}XmlChildIns.Removed) then
    begin
        {self.}XmlChildIns := new Ins(self, {self.}Prefix, "ins");
        container_.Set({self.}XmlChildIns);
    end
    return {self.}XmlChildIns and not {self.}XmlChildIns.Removed ? {self.}XmlChildIns : fallback_.XmlChildIns;
end;

function P.WriteXmlChildIns(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildIns) then
            {self.}RemoveChild({self.}XmlChildIns);
    end
    else if v is class(Ins) then
    begin
        {self.}XmlChildIns := v;
        container_.Set({self.}XmlChildIns);
    end
    else begin
        raise "Invalid assignment: Ins expects Ins or nil";
    end
end;

function P.ReadXmlChildDel(): Del;
begin
    if tslassigning and (ifnil({self.}XmlChildDel) or {self.}XmlChildDel.Removed) then
    begin
        {self.}XmlChildDel := new Del(self, {self.}Prefix, "del");
        container_.Set({self.}XmlChildDel);
    end
    return {self.}XmlChildDel and not {self.}XmlChildDel.Removed ? {self.}XmlChildDel : fallback_.XmlChildDel;
end;

function P.WriteXmlChildDel(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildDel) then
            {self.}RemoveChild({self.}XmlChildDel);
    end
    else if v is class(Del) then
    begin
        {self.}XmlChildDel := v;
        container_.Set({self.}XmlChildDel);
    end
    else begin
        raise "Invalid assignment: Del expects Del or nil";
    end
end;

function P.ReadSdts(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "sdt", ind);
end;

function P.WriteSdts(_index: integer; _value: nil_OR_Sdt);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadSdts(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "sdt", ind, _value) then
            raise format("Index out of range: Sdts[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Sdts expects nil or Sdt";
    end
end;

function P.ReadRs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "r", ind);
end;

function P.WriteRs(_index: integer; _value: nil_OR_R);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadRs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "r", ind, _value) then
            raise format("Index out of range: Rs[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Rs expects nil or R";
    end
end;

function P.ReadCommentRangeStarts(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "commentRangeStart", ind);
end;

function P.WriteCommentRangeStarts(_index: integer; _value: nil_OR_CommentRange);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadCommentRangeStarts(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "commentRangeStart", ind, _value) then
            raise format("Index out of range: CommentRangeStarts[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: CommentRangeStarts expects nil or CommentRange";
    end
end;

function P.ReadCommentRangeEnds(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "commentRangeEnd", ind);
end;

function P.WriteCommentRangeEnds(_index: integer; _value: nil_OR_CommentRange);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadCommentRangeEnds(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "commentRangeEnd", ind, _value) then
            raise format("Index out of range: CommentRangeEnds[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: CommentRangeEnds expects nil or CommentRange";
    end
end;

function P.ReadBookmarkStarts(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "bookmarkStart", ind);
end;

function P.WriteBookmarkStarts(_index: integer; _value: nil_OR_Bookmark);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadBookmarkStarts(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "bookmarkStart", ind, _value) then
            raise format("Index out of range: BookmarkStarts[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: BookmarkStarts expects nil or Bookmark";
    end
end;

function P.ReadBookmarkEnds(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "bookmarkEnd", ind);
end;

function P.WriteBookmarkEnds(_index: integer; _value: nil_OR_Bookmark);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadBookmarkEnds(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "bookmarkEnd", ind, _value) then
            raise format("Index out of range: BookmarkEnds[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: BookmarkEnds expects nil or Bookmark";
    end
end;

function P.ReadHyperlinks(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "hyperlink", ind);
end;

function P.WriteHyperlinks(_index: integer; _value: nil_OR_HyperLink);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadHyperlinks(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "hyperlink", ind, _value) then
            raise format("Index out of range: Hyperlinks[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Hyperlinks expects nil or HyperLink";
    end
end;

function P.ReadFldSimples(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "fldSimple", ind);
end;

function P.WriteFldSimples(_index: integer; _value: nil_OR_FldSimple);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadFldSimples(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "fldSimple", ind, _value) then
            raise format("Index out of range: FldSimples[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: FldSimples expects nil or FldSimple";
    end
end;

function P.AddSdt(): Sdt;
begin
    obj := new Sdt(self, {self.}Prefix, "sdt");
    container_.Insert(obj);
    return obj;
end;

function P.AddR(): R;
begin
    obj := new R(self, {self.}Prefix, "r");
    container_.Insert(obj);
    return obj;
end;

function P.AddCommentRangeStart(): CommentRange;
begin
    obj := new CommentRange(self, {self.}Prefix, "commentRangeStart");
    container_.Insert(obj);
    return obj;
end;

function P.AddCommentRangeEnd(): CommentRange;
begin
    obj := new CommentRange(self, {self.}Prefix, "commentRangeEnd");
    container_.Insert(obj);
    return obj;
end;

function P.AddBookmarkStart(): Bookmark;
begin
    obj := new Bookmark(self, {self.}Prefix, "bookmarkStart");
    container_.Insert(obj);
    return obj;
end;

function P.AddBookmarkEnd(): Bookmark;
begin
    obj := new Bookmark(self, {self.}Prefix, "bookmarkEnd");
    container_.Insert(obj);
    return obj;
end;

function P.AddHyperLink(): HyperLink;
begin
    obj := new HyperLink(self, {self.}Prefix, "hyperlink");
    container_.Insert(obj);
    return obj;
end;

function P.AddFldSimple(): FldSimple;
begin
    obj := new FldSimple(self, {self.}Prefix, "fldSimple");
    container_.Insert(obj);
    return obj;
end;

function P.AppendSdt(): Sdt;
begin
    obj := new Sdt(self, {self.}Prefix, "sdt");
    container_.Append(obj);
    return obj;
end;

function P.AppendR(): R;
begin
    obj := new R(self, {self.}Prefix, "r");
    container_.Append(obj);
    return obj;
end;

function P.AppendCommentRangeStart(): CommentRange;
begin
    obj := new CommentRange(self, {self.}Prefix, "commentRangeStart");
    container_.Append(obj);
    return obj;
end;

function P.AppendCommentRangeEnd(): CommentRange;
begin
    obj := new CommentRange(self, {self.}Prefix, "commentRangeEnd");
    container_.Append(obj);
    return obj;
end;

function P.AppendBookmarkStart(): Bookmark;
begin
    obj := new Bookmark(self, {self.}Prefix, "bookmarkStart");
    container_.Append(obj);
    return obj;
end;

function P.AppendBookmarkEnd(): Bookmark;
begin
    obj := new Bookmark(self, {self.}Prefix, "bookmarkEnd");
    container_.Append(obj);
    return obj;
end;

function P.AppendHyperLink(): HyperLink;
begin
    obj := new HyperLink(self, {self.}Prefix, "hyperlink");
    container_.Append(obj);
    return obj;
end;

function P.AppendFldSimple(): FldSimple;
begin
    obj := new FldSimple(self, {self.}Prefix, "fldSimple");
    container_.Append(obj);
    return obj;
end;

function FldSimple.Create();overload;
begin
    {self.}Create(nil, "w", "fldSimple");
end;

function FldSimple.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function FldSimple.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function FldSimple.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "dirty": makeweakref(thisFunction(WriteXmlAttrDirty)),
        pre + "fldLock": makeweakref(thisFunction(WriteXmlAttrFldLock)),
        pre + "instr": makeweakref(thisFunction(WriteXmlAttrInstr)),
    );
    sorted_child_ := array(
        pre + "r": array(0, makeweakref(thisFunction(AppendR))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function FldSimple.Copy(_obj: FldSimple);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Dirty) then
        {self.}Dirty := _obj.Dirty;
    if not ifnil(_obj.FldLock) then
        {self.}FldLock := _obj.FldLock;
    if not ifnil(_obj.Instr) then
        {self.}Instr := _obj.Instr;
    tslassigning := tslassigning_backup;
end;

function FldSimple.ConvertToPoint();override;
begin
    elems := {self.}Rs();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function FldSimple.ReadXmlAttrDirty();
begin
    return ifnil({self.}XmlAttrDirty.Value) ? fallback_.XmlAttrDirty.Value : {self.}XmlAttrDirty.Value;
end;

function FldSimple.WriteXmlAttrDirty(_value: any);
begin
    if ifnil({self.}XmlAttrDirty) then
    begin
        {self.}XmlAttrDirty := new OpenXmlAttribute({self.}Prefix, "dirty", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "dirty" : "dirty"] := {self.}XmlAttrDirty;
    end
    {self.}XmlAttrDirty.Value := _value;
end;

function FldSimple.ReadXmlAttrFldLock();
begin
    return ifnil({self.}XmlAttrFldLock.Value) ? fallback_.XmlAttrFldLock.Value : {self.}XmlAttrFldLock.Value;
end;

function FldSimple.WriteXmlAttrFldLock(_value: any);
begin
    if ifnil({self.}XmlAttrFldLock) then
    begin
        {self.}XmlAttrFldLock := new OpenXmlAttribute({self.}Prefix, "fldLock", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "fldLock" : "fldLock"] := {self.}XmlAttrFldLock;
    end
    {self.}XmlAttrFldLock.Value := _value;
end;

function FldSimple.ReadXmlAttrInstr();
begin
    return ifnil({self.}XmlAttrInstr.Value) ? fallback_.XmlAttrInstr.Value : {self.}XmlAttrInstr.Value;
end;

function FldSimple.WriteXmlAttrInstr(_value: any);
begin
    if ifnil({self.}XmlAttrInstr) then
    begin
        {self.}XmlAttrInstr := new OpenXmlAttribute({self.}Prefix, "instr", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "instr" : "instr"] := {self.}XmlAttrInstr;
    end
    {self.}XmlAttrInstr.Value := _value;
end;

function FldSimple.ReadRs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "r", ind);
end;

function FldSimple.WriteRs(_index: integer; _value: nil_OR_R);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadRs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "r", ind, _value) then
            raise format("Index out of range: Rs[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Rs expects nil or R";
    end
end;

function FldSimple.AddR(): R;
begin
    obj := new R(self, {self.}Prefix, "r");
    container_.Insert(obj);
    return obj;
end;

function FldSimple.AppendR(): R;
begin
    obj := new R(self, {self.}Prefix, "r");
    container_.Append(obj);
    return obj;
end;

function CommentRange.Create();overload;
begin
    {self.}Create(nil, "w", "");
end;

function CommentRange.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function CommentRange.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function CommentRange.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "id": makeweakref(thisFunction(WriteXmlAttrId)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function CommentRange.Copy(_obj: CommentRange);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Id) then
        {self.}Id := _obj.Id;
    tslassigning := tslassigning_backup;
end;

function CommentRange.ConvertToPoint();override;
begin

end;

function CommentRange.ReadXmlAttrId();
begin
    return ifnil({self.}XmlAttrId.Value) ? fallback_.XmlAttrId.Value : {self.}XmlAttrId.Value;
end;

function CommentRange.WriteXmlAttrId(_value: any);
begin
    if ifnil({self.}XmlAttrId) then
    begin
        {self.}XmlAttrId := new OpenXmlAttribute({self.}Prefix, "id", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "id" : "id"] := {self.}XmlAttrId;
    end
    {self.}XmlAttrId.Value := _value;
end;

function HyperLink.Create();overload;
begin
    {self.}Create(nil, "w", "hyperlink");
end;

function HyperLink.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function HyperLink.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function HyperLink.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "anchor": makeweakref(thisFunction(WriteXmlAttrAnchor)),
        "r:id": makeweakref(thisFunction(WriteXmlAttrId)),
        pre + "history": makeweakref(thisFunction(WriteXmlAttrHistory)),
    );
    sorted_child_ := array(
        pre + "r": array(0, makeweakref(thisFunction(AppendR))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function HyperLink.Copy(_obj: HyperLink);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Anchor) then
        {self.}Anchor := _obj.Anchor;
    if not ifnil(_obj.Id) then
        {self.}Id := _obj.Id;
    if not ifnil(_obj.History) then
        {self.}History := _obj.History;
    tslassigning := tslassigning_backup;
end;

function HyperLink.ConvertToPoint();override;
begin
    elems := {self.}Rs();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function HyperLink.ReadXmlAttrAnchor();
begin
    return ifnil({self.}XmlAttrAnchor.Value) ? fallback_.XmlAttrAnchor.Value : {self.}XmlAttrAnchor.Value;
end;

function HyperLink.WriteXmlAttrAnchor(_value: any);
begin
    if ifnil({self.}XmlAttrAnchor) then
    begin
        {self.}XmlAttrAnchor := new OpenXmlAttribute({self.}Prefix, "anchor", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "anchor" : "anchor"] := {self.}XmlAttrAnchor;
    end
    {self.}XmlAttrAnchor.Value := _value;
end;

function HyperLink.ReadXmlAttrId();
begin
    return ifnil({self.}XmlAttrId.Value) ? fallback_.XmlAttrId.Value : {self.}XmlAttrId.Value;
end;

function HyperLink.WriteXmlAttrId(_value: any);
begin
    if ifnil({self.}XmlAttrId) then
    begin
        {self.}XmlAttrId := new OpenXmlAttribute("r", "id", nil);
        attributes_["r:id"] := {self.}XmlAttrId;
    end
    {self.}XmlAttrId.Value := _value;
end;

function HyperLink.ReadXmlAttrHistory();
begin
    return ifnil({self.}XmlAttrHistory.Value) ? fallback_.XmlAttrHistory.Value : {self.}XmlAttrHistory.Value;
end;

function HyperLink.WriteXmlAttrHistory(_value: any);
begin
    if ifnil({self.}XmlAttrHistory) then
    begin
        {self.}XmlAttrHistory := new OpenXmlAttribute({self.}Prefix, "history", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "history" : "history"] := {self.}XmlAttrHistory;
    end
    {self.}XmlAttrHistory.Value := _value;
end;

function HyperLink.ReadRs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "r", ind);
end;

function HyperLink.WriteRs(_index: integer; _value: nil_OR_R);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadRs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "r", ind, _value) then
            raise format("Index out of range: Rs[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Rs expects nil or R";
    end
end;

function HyperLink.AddR(): R;
begin
    obj := new R(self, {self.}Prefix, "r");
    container_.Insert(obj);
    return obj;
end;

function HyperLink.AppendR(): R;
begin
    obj := new R(self, {self.}Prefix, "r");
    container_.Append(obj);
    return obj;
end;

function Bookmark.Create();overload;
begin
    {self.}Create(nil, "w", "");
end;

function Bookmark.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Bookmark.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Bookmark.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "name": makeweakref(thisFunction(WriteXmlAttrName)),
        pre + "id": makeweakref(thisFunction(WriteXmlAttrId)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Bookmark.Copy(_obj: Bookmark);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Name) then
        {self.}Name := _obj.Name;
    if not ifnil(_obj.Id) then
        {self.}Id := _obj.Id;
    tslassigning := tslassigning_backup;
end;

function Bookmark.ConvertToPoint();override;
begin

end;

function Bookmark.ReadXmlAttrName();
begin
    return ifnil({self.}XmlAttrName.Value) ? fallback_.XmlAttrName.Value : {self.}XmlAttrName.Value;
end;

function Bookmark.WriteXmlAttrName(_value: any);
begin
    if ifnil({self.}XmlAttrName) then
    begin
        {self.}XmlAttrName := new OpenXmlAttribute({self.}Prefix, "name", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "name" : "name"] := {self.}XmlAttrName;
    end
    {self.}XmlAttrName.Value := _value;
end;

function Bookmark.ReadXmlAttrId();
begin
    return ifnil({self.}XmlAttrId.Value) ? fallback_.XmlAttrId.Value : {self.}XmlAttrId.Value;
end;

function Bookmark.WriteXmlAttrId(_value: any);
begin
    if ifnil({self.}XmlAttrId) then
    begin
        {self.}XmlAttrId := new OpenXmlAttribute({self.}Prefix, "id", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "id" : "id"] := {self.}XmlAttrId;
    end
    {self.}XmlAttrId.Value := _value;
end;

function PPr.Create();overload;
begin
    {self.}Create(nil, "w", "pPr");
end;

function PPr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function PPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function PPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "sectPr": array(0, makeweakref(thisFunction(ReadXmlChildSectPr))),
        pre + "tabs": array(1, makeweakref(thisFunction(ReadXmlChildTabs))),
        pre + "bidi": array(2, makeweakref(thisFunction(ReadXmlChildBidi))),
        pre + "widowControl": array(3, makeweakref(thisFunction(ReadXmlChildWidowControl))),
        pre + "snapToGrid": array(4, makeweakref(thisFunction(ReadXmlChildSnapToGrid))),
        pre + "pStyle": array(5, makeweakref(thisFunction(ReadXmlChildPStyle))),
        pre + "numPr": array(6, makeweakref(thisFunction(ReadXmlChildNumPr))),
        pre + "jc": array(7, makeweakref(thisFunction(ReadXmlChildJc))),
        pre + "ind": array(8, makeweakref(thisFunction(ReadXmlChildInd))),
        pre + "keepNext": array(9, makeweakref(thisFunction(ReadXmlChildKeepNext))),
        pre + "keepLines": array(10, makeweakref(thisFunction(ReadXmlChildKeepLines))),
        pre + "mirrorIndents": array(11, makeweakref(thisFunction(ReadXmlChildMirrorIndents))),
        pre + "kinsoku": array(12, makeweakref(thisFunction(ReadXmlChildKinsoku))),
        pre + "pageBreakBefore": array(13, makeweakref(thisFunction(ReadXmlChildPageBreakBefore))),
        pre + "suppressAutoHyphens": array(14, makeweakref(thisFunction(ReadXmlChildSuppressAutoHyphens))),
        pre + "suppressLineNumbers": array(15, makeweakref(thisFunction(ReadXmlChildSuppressLineNumbers))),
        pre + "suppressOverlap": array(16, makeweakref(thisFunction(ReadXmlChildSuppressOverlap))),
        pre + "overflowPunct": array(17, makeweakref(thisFunction(ReadXmlChildOverflowPunct))),
        pre + "adjustRightInd": array(18, makeweakref(thisFunction(ReadXmlChildAdjustRightInd))),
        pre + "spacing": array(19, makeweakref(thisFunction(ReadXmlChildSpacing))),
        pre + "outlineLvl": array(20, makeweakref(thisFunction(ReadXmlChildOutlineLvl))),
        pre + "autoSpaceDE": array(21, makeweakref(thisFunction(ReadXmlChildAutoSpaceDE))),
        pre + "autoSpaceDN": array(22, makeweakref(thisFunction(ReadXmlChildAutoSpaceDN))),
        pre + "rPr": array(23, makeweakref(thisFunction(ReadXmlChildRPr))),
        pre + "pBdr": array(24, makeweakref(thisFunction(ReadXmlChildPBdr))),
        pre + "contextualSpacing": array(25, makeweakref(thisFunction(ReadXmlChildContextualSpacing))),
        pre + "shd": array(26, makeweakref(thisFunction(ReadXmlChildShd))),
        pre + "wordWrap": array(27, makeweakref(thisFunction(ReadXmlChildWordWrap))),
        pre + "divId": array(28, makeweakref(thisFunction(ReadXmlChildDivId))),
        pre + "cnfStyle": array(29, makeweakref(thisFunction(ReadXmlChildCnfStyle))),
        pre + "framePr": array(30, makeweakref(thisFunction(ReadXmlChildFramePr))),
        pre + "textboxTightWrap": array(31, makeweakref(thisFunction(ReadXmlChildTextboxTightWrap))),
        pre + "topLinePunct": array(32, makeweakref(thisFunction(ReadXmlChildTopLinePunct))),
        pre + "textAlignment": array(33, makeweakref(thisFunction(ReadXmlChildTextAlignment))),
        pre + "textDirection": array(34, makeweakref(thisFunction(ReadXmlChildTextDirection))),
        "w15:wordWrap": array(35, makeweakref(thisFunction(ReadXmlChildCollapsed))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function PPr.Copy(_obj: PPr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildSectPr) then
        {self.}SectPr.Copy(_obj.XmlChildSectPr);
    if not ifnil(_obj.XmlChildTabs) then
        {self.}Tabs.Copy(_obj.XmlChildTabs);
    if not ifnil(_obj.XmlChildBidi) then
        ifnil({self.}XmlChildBidi) ? {self.}Bidi.Copy(_obj.XmlChildBidi) : {self.}XmlChildBidi.Copy(_obj.XmlChildBidi);
    if not ifnil(_obj.XmlChildWidowControl) then
        ifnil({self.}XmlChildWidowControl) ? {self.}WidowControl.Copy(_obj.XmlChildWidowControl) : {self.}XmlChildWidowControl.Copy(_obj.XmlChildWidowControl);
    if not ifnil(_obj.XmlChildSnapToGrid) then
        ifnil({self.}XmlChildSnapToGrid) ? {self.}SnapToGrid.Copy(_obj.XmlChildSnapToGrid) : {self.}XmlChildSnapToGrid.Copy(_obj.XmlChildSnapToGrid);
    if not ifnil(_obj.XmlChildPStyle) then
        {self.}PStyle.Copy(_obj.XmlChildPStyle);
    if not ifnil(_obj.XmlChildNumPr) then
        {self.}NumPr.Copy(_obj.XmlChildNumPr);
    if not ifnil(_obj.XmlChildJc) then
        {self.}Jc.Copy(_obj.XmlChildJc);
    if not ifnil(_obj.XmlChildInd) then
        {self.}Ind.Copy(_obj.XmlChildInd);
    if not ifnil(_obj.XmlChildKeepNext) then
        ifnil({self.}XmlChildKeepNext) ? {self.}KeepNext.Copy(_obj.XmlChildKeepNext) : {self.}XmlChildKeepNext.Copy(_obj.XmlChildKeepNext);
    if not ifnil(_obj.XmlChildKeepLines) then
        ifnil({self.}XmlChildKeepLines) ? {self.}KeepLines.Copy(_obj.XmlChildKeepLines) : {self.}XmlChildKeepLines.Copy(_obj.XmlChildKeepLines);
    if not ifnil(_obj.XmlChildMirrorIndents) then
        ifnil({self.}XmlChildMirrorIndents) ? {self.}MirrorIndents.Copy(_obj.XmlChildMirrorIndents) : {self.}XmlChildMirrorIndents.Copy(_obj.XmlChildMirrorIndents);
    if not ifnil(_obj.XmlChildKinsoku) then
        {self.}Kinsoku.Copy(_obj.XmlChildKinsoku);
    if not ifnil(_obj.XmlChildPageBreakBefore) then
        ifnil({self.}XmlChildPageBreakBefore) ? {self.}PageBreakBefore.Copy(_obj.XmlChildPageBreakBefore) : {self.}XmlChildPageBreakBefore.Copy(_obj.XmlChildPageBreakBefore);
    if not ifnil(_obj.XmlChildSuppressAutoHyphens) then
        ifnil({self.}XmlChildSuppressAutoHyphens) ? {self.}SuppressAutoHyphens.Copy(_obj.XmlChildSuppressAutoHyphens) : {self.}XmlChildSuppressAutoHyphens.Copy(_obj.XmlChildSuppressAutoHyphens);
    if not ifnil(_obj.XmlChildSuppressLineNumbers) then
        ifnil({self.}XmlChildSuppressLineNumbers) ? {self.}SuppressLineNumbers.Copy(_obj.XmlChildSuppressLineNumbers) : {self.}XmlChildSuppressLineNumbers.Copy(_obj.XmlChildSuppressLineNumbers);
    if not ifnil(_obj.XmlChildSuppressOverlap) then
        ifnil({self.}XmlChildSuppressOverlap) ? {self.}SuppressOverlap.Copy(_obj.XmlChildSuppressOverlap) : {self.}XmlChildSuppressOverlap.Copy(_obj.XmlChildSuppressOverlap);
    if not ifnil(_obj.XmlChildOverflowPunct) then
        {self.}OverflowPunct.Copy(_obj.XmlChildOverflowPunct);
    if not ifnil(_obj.XmlChildAdjustRightInd) then
        {self.}AdjustRightInd.Copy(_obj.XmlChildAdjustRightInd);
    if not ifnil(_obj.XmlChildSpacing) then
        {self.}Spacing.Copy(_obj.XmlChildSpacing);
    if not ifnil(_obj.XmlChildOutlineLvl) then
        {self.}OutlineLvl.Copy(_obj.XmlChildOutlineLvl);
    if not ifnil(_obj.XmlChildAutoSpaceDE) then
        {self.}AutoSpaceDE.Copy(_obj.XmlChildAutoSpaceDE);
    if not ifnil(_obj.XmlChildAutoSpaceDN) then
        {self.}AutoSpaceDN.Copy(_obj.XmlChildAutoSpaceDN);
    if not ifnil(_obj.XmlChildRPr) then
        {self.}RPr.Copy(_obj.XmlChildRPr);
    if not ifnil(_obj.XmlChildPBdr) then
        {self.}PBdr.Copy(_obj.XmlChildPBdr);
    if not ifnil(_obj.XmlChildContextualSpacing) then
        ifnil({self.}XmlChildContextualSpacing) ? {self.}ContextualSpacing.Copy(_obj.XmlChildContextualSpacing) : {self.}XmlChildContextualSpacing.Copy(_obj.XmlChildContextualSpacing);
    if not ifnil(_obj.XmlChildShd) then
        {self.}Shd.Copy(_obj.XmlChildShd);
    if not ifnil(_obj.XmlChildWordWrap) then
        {self.}WordWrap.Copy(_obj.XmlChildWordWrap);
    if not ifnil(_obj.XmlChildDivId) then
        {self.}DivId.Copy(_obj.XmlChildDivId);
    if not ifnil(_obj.XmlChildCnfStyle) then
        {self.}CnfStyle.Copy(_obj.XmlChildCnfStyle);
    if not ifnil(_obj.XmlChildFramePr) then
        {self.}FramePr.Copy(_obj.XmlChildFramePr);
    if not ifnil(_obj.XmlChildTextboxTightWrap) then
        {self.}TextboxTightWrap.Copy(_obj.XmlChildTextboxTightWrap);
    if not ifnil(_obj.XmlChildTopLinePunct) then
        {self.}TopLinePunct.Copy(_obj.XmlChildTopLinePunct);
    if not ifnil(_obj.XmlChildTextAlignment) then
        {self.}TextAlignment.Copy(_obj.XmlChildTextAlignment);
    if not ifnil(_obj.XmlChildTextDirection) then
        {self.}TextDirection.Copy(_obj.XmlChildTextDirection);
    if not ifnil(_obj.XmlChildCollapsed) then
        {self.}Collapsed.Copy(_obj.XmlChildCollapsed);
    tslassigning := tslassigning_backup;
end;

function PPr.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildSectPr) then
        {self.}XmlChildSectPr.ConvertToPoint();
    if not ifnil({self.}XmlChildTabs) then
        {self.}XmlChildTabs.ConvertToPoint();
    if not ifnil({self.}XmlChildPStyle) then
        {self.}XmlChildPStyle.ConvertToPoint();
    if not ifnil({self.}XmlChildNumPr) then
        {self.}XmlChildNumPr.ConvertToPoint();
    if not ifnil({self.}XmlChildJc) then
        {self.}XmlChildJc.ConvertToPoint();
    if not ifnil({self.}XmlChildInd) then
        {self.}XmlChildInd.ConvertToPoint();
    if not ifnil({self.}XmlChildKinsoku) then
        {self.}XmlChildKinsoku.ConvertToPoint();
    if not ifnil({self.}XmlChildOverflowPunct) then
        {self.}XmlChildOverflowPunct.ConvertToPoint();
    if not ifnil({self.}XmlChildAdjustRightInd) then
        {self.}XmlChildAdjustRightInd.ConvertToPoint();
    if not ifnil({self.}XmlChildSpacing) then
        {self.}XmlChildSpacing.ConvertToPoint();
    if not ifnil({self.}XmlChildOutlineLvl) then
        {self.}XmlChildOutlineLvl.ConvertToPoint();
    if not ifnil({self.}XmlChildAutoSpaceDE) then
        {self.}XmlChildAutoSpaceDE.ConvertToPoint();
    if not ifnil({self.}XmlChildAutoSpaceDN) then
        {self.}XmlChildAutoSpaceDN.ConvertToPoint();
    if not ifnil({self.}XmlChildRPr) then
        {self.}XmlChildRPr.ConvertToPoint();
    if not ifnil({self.}XmlChildPBdr) then
        {self.}XmlChildPBdr.ConvertToPoint();
    if not ifnil({self.}XmlChildShd) then
        {self.}XmlChildShd.ConvertToPoint();
    if not ifnil({self.}XmlChildWordWrap) then
        {self.}XmlChildWordWrap.ConvertToPoint();
    if not ifnil({self.}XmlChildDivId) then
        {self.}XmlChildDivId.ConvertToPoint();
    if not ifnil({self.}XmlChildCnfStyle) then
        {self.}XmlChildCnfStyle.ConvertToPoint();
    if not ifnil({self.}XmlChildFramePr) then
        {self.}XmlChildFramePr.ConvertToPoint();
    if not ifnil({self.}XmlChildTextboxTightWrap) then
        {self.}XmlChildTextboxTightWrap.ConvertToPoint();
    if not ifnil({self.}XmlChildTopLinePunct) then
        {self.}XmlChildTopLinePunct.ConvertToPoint();
    if not ifnil({self.}XmlChildTextAlignment) then
        {self.}XmlChildTextAlignment.ConvertToPoint();
    if not ifnil({self.}XmlChildTextDirection) then
        {self.}XmlChildTextDirection.ConvertToPoint();
    if not ifnil({self.}XmlChildCollapsed) then
        {self.}XmlChildCollapsed.ConvertToPoint();
end;

function PPr.ReadXmlChildBidi();
begin
    if tslassigning and (ifnil({self.}XmlChildBidi) or {self.}XmlChildBidi.Removed) then
    begin
        {self.}XmlChildBidi := new OpenXmlSimpleType(self, {self.}Prefix, "bidi");
        container_.Set({self.}XmlChildBidi);
    end
    return {self.}XmlChildBidi and not {self.}XmlChildBidi.Removed ? {self.}XmlChildBidi : fallback_.XmlChildBidi;
end;

function PPr.WriteXmlChildBidi(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildBidi) then
            {self.}RemoveChild({self.}XmlChildBidi);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildBidi := _value;
        container_.Set({self.}XmlChildBidi);
    end
    else begin
        raise "Invalid assignment: Bidi expects nil or OpenXmlSimpleType";
    end
end;

function PPr.ReadXmlChildWidowControl();
begin
    if tslassigning and (ifnil({self.}XmlChildWidowControl) or {self.}XmlChildWidowControl.Removed) then
    begin
        {self.}XmlChildWidowControl := new OpenXmlSimpleType(self, {self.}Prefix, "widowControl");
        container_.Set({self.}XmlChildWidowControl);
    end
    return {self.}XmlChildWidowControl and not {self.}XmlChildWidowControl.Removed ? {self.}XmlChildWidowControl : fallback_.XmlChildWidowControl;
end;

function PPr.WriteXmlChildWidowControl(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildWidowControl) then
            {self.}RemoveChild({self.}XmlChildWidowControl);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildWidowControl := _value;
        container_.Set({self.}XmlChildWidowControl);
    end
    else begin
        raise "Invalid assignment: WidowControl expects nil or OpenXmlSimpleType";
    end
end;

function PPr.ReadXmlChildSnapToGrid();
begin
    if tslassigning and (ifnil({self.}XmlChildSnapToGrid) or {self.}XmlChildSnapToGrid.Removed) then
    begin
        {self.}XmlChildSnapToGrid := new OpenXmlSimpleType(self, {self.}Prefix, "snapToGrid");
        container_.Set({self.}XmlChildSnapToGrid);
    end
    return {self.}XmlChildSnapToGrid and not {self.}XmlChildSnapToGrid.Removed ? {self.}XmlChildSnapToGrid : fallback_.XmlChildSnapToGrid;
end;

function PPr.WriteXmlChildSnapToGrid(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildSnapToGrid) then
            {self.}RemoveChild({self.}XmlChildSnapToGrid);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildSnapToGrid := _value;
        container_.Set({self.}XmlChildSnapToGrid);
    end
    else begin
        raise "Invalid assignment: SnapToGrid expects nil or OpenXmlSimpleType";
    end
end;

function PPr.ReadXmlChildKeepNext();
begin
    if tslassigning and (ifnil({self.}XmlChildKeepNext) or {self.}XmlChildKeepNext.Removed) then
    begin
        {self.}XmlChildKeepNext := new OpenXmlSimpleType(self, {self.}Prefix, "keepNext");
        container_.Set({self.}XmlChildKeepNext);
    end
    return {self.}XmlChildKeepNext and not {self.}XmlChildKeepNext.Removed ? {self.}XmlChildKeepNext : fallback_.XmlChildKeepNext;
end;

function PPr.WriteXmlChildKeepNext(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildKeepNext) then
            {self.}RemoveChild({self.}XmlChildKeepNext);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildKeepNext := _value;
        container_.Set({self.}XmlChildKeepNext);
    end
    else begin
        raise "Invalid assignment: KeepNext expects nil or OpenXmlSimpleType";
    end
end;

function PPr.ReadXmlChildKeepLines();
begin
    if tslassigning and (ifnil({self.}XmlChildKeepLines) or {self.}XmlChildKeepLines.Removed) then
    begin
        {self.}XmlChildKeepLines := new OpenXmlSimpleType(self, {self.}Prefix, "keepLines");
        container_.Set({self.}XmlChildKeepLines);
    end
    return {self.}XmlChildKeepLines and not {self.}XmlChildKeepLines.Removed ? {self.}XmlChildKeepLines : fallback_.XmlChildKeepLines;
end;

function PPr.WriteXmlChildKeepLines(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildKeepLines) then
            {self.}RemoveChild({self.}XmlChildKeepLines);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildKeepLines := _value;
        container_.Set({self.}XmlChildKeepLines);
    end
    else begin
        raise "Invalid assignment: KeepLines expects nil or OpenXmlSimpleType";
    end
end;

function PPr.ReadXmlChildMirrorIndents();
begin
    if tslassigning and (ifnil({self.}XmlChildMirrorIndents) or {self.}XmlChildMirrorIndents.Removed) then
    begin
        {self.}XmlChildMirrorIndents := new OpenXmlSimpleType(self, {self.}Prefix, "mirrorIndents");
        container_.Set({self.}XmlChildMirrorIndents);
    end
    return {self.}XmlChildMirrorIndents and not {self.}XmlChildMirrorIndents.Removed ? {self.}XmlChildMirrorIndents : fallback_.XmlChildMirrorIndents;
end;

function PPr.WriteXmlChildMirrorIndents(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildMirrorIndents) then
            {self.}RemoveChild({self.}XmlChildMirrorIndents);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildMirrorIndents := _value;
        container_.Set({self.}XmlChildMirrorIndents);
    end
    else begin
        raise "Invalid assignment: MirrorIndents expects nil or OpenXmlSimpleType";
    end
end;

function PPr.ReadXmlChildPageBreakBefore();
begin
    if tslassigning and (ifnil({self.}XmlChildPageBreakBefore) or {self.}XmlChildPageBreakBefore.Removed) then
    begin
        {self.}XmlChildPageBreakBefore := new OpenXmlSimpleType(self, {self.}Prefix, "pageBreakBefore");
        container_.Set({self.}XmlChildPageBreakBefore);
    end
    return {self.}XmlChildPageBreakBefore and not {self.}XmlChildPageBreakBefore.Removed ? {self.}XmlChildPageBreakBefore : fallback_.XmlChildPageBreakBefore;
end;

function PPr.WriteXmlChildPageBreakBefore(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildPageBreakBefore) then
            {self.}RemoveChild({self.}XmlChildPageBreakBefore);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildPageBreakBefore := _value;
        container_.Set({self.}XmlChildPageBreakBefore);
    end
    else begin
        raise "Invalid assignment: PageBreakBefore expects nil or OpenXmlSimpleType";
    end
end;

function PPr.ReadXmlChildSuppressAutoHyphens();
begin
    if tslassigning and (ifnil({self.}XmlChildSuppressAutoHyphens) or {self.}XmlChildSuppressAutoHyphens.Removed) then
    begin
        {self.}XmlChildSuppressAutoHyphens := new OpenXmlSimpleType(self, {self.}Prefix, "suppressAutoHyphens");
        container_.Set({self.}XmlChildSuppressAutoHyphens);
    end
    return {self.}XmlChildSuppressAutoHyphens and not {self.}XmlChildSuppressAutoHyphens.Removed ? {self.}XmlChildSuppressAutoHyphens : fallback_.XmlChildSuppressAutoHyphens;
end;

function PPr.WriteXmlChildSuppressAutoHyphens(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildSuppressAutoHyphens) then
            {self.}RemoveChild({self.}XmlChildSuppressAutoHyphens);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildSuppressAutoHyphens := _value;
        container_.Set({self.}XmlChildSuppressAutoHyphens);
    end
    else begin
        raise "Invalid assignment: SuppressAutoHyphens expects nil or OpenXmlSimpleType";
    end
end;

function PPr.ReadXmlChildSuppressLineNumbers();
begin
    if tslassigning and (ifnil({self.}XmlChildSuppressLineNumbers) or {self.}XmlChildSuppressLineNumbers.Removed) then
    begin
        {self.}XmlChildSuppressLineNumbers := new OpenXmlSimpleType(self, {self.}Prefix, "suppressLineNumbers");
        container_.Set({self.}XmlChildSuppressLineNumbers);
    end
    return {self.}XmlChildSuppressLineNumbers and not {self.}XmlChildSuppressLineNumbers.Removed ? {self.}XmlChildSuppressLineNumbers : fallback_.XmlChildSuppressLineNumbers;
end;

function PPr.WriteXmlChildSuppressLineNumbers(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildSuppressLineNumbers) then
            {self.}RemoveChild({self.}XmlChildSuppressLineNumbers);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildSuppressLineNumbers := _value;
        container_.Set({self.}XmlChildSuppressLineNumbers);
    end
    else begin
        raise "Invalid assignment: SuppressLineNumbers expects nil or OpenXmlSimpleType";
    end
end;

function PPr.ReadXmlChildSuppressOverlap();
begin
    if tslassigning and (ifnil({self.}XmlChildSuppressOverlap) or {self.}XmlChildSuppressOverlap.Removed) then
    begin
        {self.}XmlChildSuppressOverlap := new OpenXmlSimpleType(self, {self.}Prefix, "suppressOverlap");
        container_.Set({self.}XmlChildSuppressOverlap);
    end
    return {self.}XmlChildSuppressOverlap and not {self.}XmlChildSuppressOverlap.Removed ? {self.}XmlChildSuppressOverlap : fallback_.XmlChildSuppressOverlap;
end;

function PPr.WriteXmlChildSuppressOverlap(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildSuppressOverlap) then
            {self.}RemoveChild({self.}XmlChildSuppressOverlap);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildSuppressOverlap := _value;
        container_.Set({self.}XmlChildSuppressOverlap);
    end
    else begin
        raise "Invalid assignment: SuppressOverlap expects nil or OpenXmlSimpleType";
    end
end;

function PPr.ReadXmlChildContextualSpacing();
begin
    if tslassigning and (ifnil({self.}XmlChildContextualSpacing) or {self.}XmlChildContextualSpacing.Removed) then
    begin
        {self.}XmlChildContextualSpacing := new OpenXmlSimpleType(self, {self.}Prefix, "contextualSpacing");
        container_.Set({self.}XmlChildContextualSpacing);
    end
    return {self.}XmlChildContextualSpacing and not {self.}XmlChildContextualSpacing.Removed ? {self.}XmlChildContextualSpacing : fallback_.XmlChildContextualSpacing;
end;

function PPr.WriteXmlChildContextualSpacing(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildContextualSpacing) then
            {self.}RemoveChild({self.}XmlChildContextualSpacing);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildContextualSpacing := _value;
        container_.Set({self.}XmlChildContextualSpacing);
    end
    else begin
        raise "Invalid assignment: ContextualSpacing expects nil or OpenXmlSimpleType";
    end
end;

function PPr.ReadXmlChildSectPr(): SectPr;
begin
    if tslassigning and (ifnil({self.}XmlChildSectPr) or {self.}XmlChildSectPr.Removed) then
    begin
        {self.}XmlChildSectPr := new SectPr(self, {self.}Prefix, "sectPr");
        container_.Set({self.}XmlChildSectPr);
    end
    return {self.}XmlChildSectPr and not {self.}XmlChildSectPr.Removed ? {self.}XmlChildSectPr : fallback_.XmlChildSectPr;
end;

function PPr.WriteXmlChildSectPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildSectPr) then
            {self.}RemoveChild({self.}XmlChildSectPr);
    end
    else if v is class(SectPr) then
    begin
        {self.}XmlChildSectPr := v;
        container_.Set({self.}XmlChildSectPr);
    end
    else begin
        raise "Invalid assignment: SectPr expects SectPr or nil";
    end
end;

function PPr.ReadXmlChildTabs(): Tabs;
begin
    if tslassigning and (ifnil({self.}XmlChildTabs) or {self.}XmlChildTabs.Removed) then
    begin
        {self.}XmlChildTabs := new Tabs(self, {self.}Prefix, "tabs");
        container_.Set({self.}XmlChildTabs);
    end
    return {self.}XmlChildTabs and not {self.}XmlChildTabs.Removed ? {self.}XmlChildTabs : fallback_.XmlChildTabs;
end;

function PPr.WriteXmlChildTabs(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTabs) then
            {self.}RemoveChild({self.}XmlChildTabs);
    end
    else if v is class(Tabs) then
    begin
        {self.}XmlChildTabs := v;
        container_.Set({self.}XmlChildTabs);
    end
    else begin
        raise "Invalid assignment: Tabs expects Tabs or nil";
    end
end;

function PPr.ReadXmlChildPStyle(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildPStyle) or {self.}XmlChildPStyle.Removed) then
    begin
        {self.}XmlChildPStyle := new PureWVal(self, {self.}Prefix, "pStyle");
        container_.Set({self.}XmlChildPStyle);
    end
    return {self.}XmlChildPStyle and not {self.}XmlChildPStyle.Removed ? {self.}XmlChildPStyle : fallback_.XmlChildPStyle;
end;

function PPr.WriteXmlChildPStyle(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPStyle) then
            {self.}RemoveChild({self.}XmlChildPStyle);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildPStyle := v;
        container_.Set({self.}XmlChildPStyle);
    end
    else begin
        raise "Invalid assignment: PStyle expects PureWVal or nil";
    end
end;

function PPr.ReadXmlChildNumPr(): NumPr;
begin
    if tslassigning and (ifnil({self.}XmlChildNumPr) or {self.}XmlChildNumPr.Removed) then
    begin
        {self.}XmlChildNumPr := new NumPr(self, {self.}Prefix, "numPr");
        container_.Set({self.}XmlChildNumPr);
    end
    return {self.}XmlChildNumPr and not {self.}XmlChildNumPr.Removed ? {self.}XmlChildNumPr : fallback_.XmlChildNumPr;
end;

function PPr.WriteXmlChildNumPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildNumPr) then
            {self.}RemoveChild({self.}XmlChildNumPr);
    end
    else if v is class(NumPr) then
    begin
        {self.}XmlChildNumPr := v;
        container_.Set({self.}XmlChildNumPr);
    end
    else begin
        raise "Invalid assignment: NumPr expects NumPr or nil";
    end
end;

function PPr.ReadXmlChildJc(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildJc) or {self.}XmlChildJc.Removed) then
    begin
        {self.}XmlChildJc := new PureWVal(self, {self.}Prefix, "jc");
        container_.Set({self.}XmlChildJc);
    end
    return {self.}XmlChildJc and not {self.}XmlChildJc.Removed ? {self.}XmlChildJc : fallback_.XmlChildJc;
end;

function PPr.WriteXmlChildJc(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildJc) then
            {self.}RemoveChild({self.}XmlChildJc);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildJc := v;
        container_.Set({self.}XmlChildJc);
    end
    else begin
        raise "Invalid assignment: Jc expects PureWVal or nil";
    end
end;

function PPr.ReadXmlChildInd(): Ind;
begin
    if tslassigning and (ifnil({self.}XmlChildInd) or {self.}XmlChildInd.Removed) then
    begin
        {self.}XmlChildInd := new Ind(self, {self.}Prefix, "ind");
        container_.Set({self.}XmlChildInd);
    end
    return {self.}XmlChildInd and not {self.}XmlChildInd.Removed ? {self.}XmlChildInd : fallback_.XmlChildInd;
end;

function PPr.WriteXmlChildInd(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildInd) then
            {self.}RemoveChild({self.}XmlChildInd);
    end
    else if v is class(Ind) then
    begin
        {self.}XmlChildInd := v;
        container_.Set({self.}XmlChildInd);
    end
    else begin
        raise "Invalid assignment: Ind expects Ind or nil";
    end
end;

function PPr.ReadXmlChildKinsoku(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildKinsoku) or {self.}XmlChildKinsoku.Removed) then
    begin
        {self.}XmlChildKinsoku := new PureWVal(self, {self.}Prefix, "kinsoku");
        container_.Set({self.}XmlChildKinsoku);
    end
    return {self.}XmlChildKinsoku and not {self.}XmlChildKinsoku.Removed ? {self.}XmlChildKinsoku : fallback_.XmlChildKinsoku;
end;

function PPr.WriteXmlChildKinsoku(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildKinsoku) then
            {self.}RemoveChild({self.}XmlChildKinsoku);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildKinsoku := v;
        container_.Set({self.}XmlChildKinsoku);
    end
    else begin
        raise "Invalid assignment: Kinsoku expects PureWVal or nil";
    end
end;

function PPr.ReadXmlChildOverflowPunct(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildOverflowPunct) or {self.}XmlChildOverflowPunct.Removed) then
    begin
        {self.}XmlChildOverflowPunct := new PureWVal(self, {self.}Prefix, "overflowPunct");
        container_.Set({self.}XmlChildOverflowPunct);
    end
    return {self.}XmlChildOverflowPunct and not {self.}XmlChildOverflowPunct.Removed ? {self.}XmlChildOverflowPunct : fallback_.XmlChildOverflowPunct;
end;

function PPr.WriteXmlChildOverflowPunct(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildOverflowPunct) then
            {self.}RemoveChild({self.}XmlChildOverflowPunct);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildOverflowPunct := v;
        container_.Set({self.}XmlChildOverflowPunct);
    end
    else begin
        raise "Invalid assignment: OverflowPunct expects PureWVal or nil";
    end
end;

function PPr.ReadXmlChildAdjustRightInd(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildAdjustRightInd) or {self.}XmlChildAdjustRightInd.Removed) then
    begin
        {self.}XmlChildAdjustRightInd := new PureWVal(self, {self.}Prefix, "adjustRightInd");
        container_.Set({self.}XmlChildAdjustRightInd);
    end
    return {self.}XmlChildAdjustRightInd and not {self.}XmlChildAdjustRightInd.Removed ? {self.}XmlChildAdjustRightInd : fallback_.XmlChildAdjustRightInd;
end;

function PPr.WriteXmlChildAdjustRightInd(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildAdjustRightInd) then
            {self.}RemoveChild({self.}XmlChildAdjustRightInd);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildAdjustRightInd := v;
        container_.Set({self.}XmlChildAdjustRightInd);
    end
    else begin
        raise "Invalid assignment: AdjustRightInd expects PureWVal or nil";
    end
end;

function PPr.ReadXmlChildSpacing(): Spacing;
begin
    if tslassigning and (ifnil({self.}XmlChildSpacing) or {self.}XmlChildSpacing.Removed) then
    begin
        {self.}XmlChildSpacing := new Spacing(self, {self.}Prefix, "spacing");
        container_.Set({self.}XmlChildSpacing);
    end
    return {self.}XmlChildSpacing and not {self.}XmlChildSpacing.Removed ? {self.}XmlChildSpacing : fallback_.XmlChildSpacing;
end;

function PPr.WriteXmlChildSpacing(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildSpacing) then
            {self.}RemoveChild({self.}XmlChildSpacing);
    end
    else if v is class(Spacing) then
    begin
        {self.}XmlChildSpacing := v;
        container_.Set({self.}XmlChildSpacing);
    end
    else begin
        raise "Invalid assignment: Spacing expects Spacing or nil";
    end
end;

function PPr.ReadXmlChildOutlineLvl(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildOutlineLvl) or {self.}XmlChildOutlineLvl.Removed) then
    begin
        {self.}XmlChildOutlineLvl := new PureWVal(self, {self.}Prefix, "outlineLvl");
        container_.Set({self.}XmlChildOutlineLvl);
    end
    return {self.}XmlChildOutlineLvl and not {self.}XmlChildOutlineLvl.Removed ? {self.}XmlChildOutlineLvl : fallback_.XmlChildOutlineLvl;
end;

function PPr.WriteXmlChildOutlineLvl(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildOutlineLvl) then
            {self.}RemoveChild({self.}XmlChildOutlineLvl);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildOutlineLvl := v;
        container_.Set({self.}XmlChildOutlineLvl);
    end
    else begin
        raise "Invalid assignment: OutlineLvl expects PureWVal or nil";
    end
end;

function PPr.ReadXmlChildAutoSpaceDE(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildAutoSpaceDE) or {self.}XmlChildAutoSpaceDE.Removed) then
    begin
        {self.}XmlChildAutoSpaceDE := new PureWVal(self, {self.}Prefix, "autoSpaceDE");
        container_.Set({self.}XmlChildAutoSpaceDE);
    end
    return {self.}XmlChildAutoSpaceDE and not {self.}XmlChildAutoSpaceDE.Removed ? {self.}XmlChildAutoSpaceDE : fallback_.XmlChildAutoSpaceDE;
end;

function PPr.WriteXmlChildAutoSpaceDE(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildAutoSpaceDE) then
            {self.}RemoveChild({self.}XmlChildAutoSpaceDE);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildAutoSpaceDE := v;
        container_.Set({self.}XmlChildAutoSpaceDE);
    end
    else begin
        raise "Invalid assignment: AutoSpaceDE expects PureWVal or nil";
    end
end;

function PPr.ReadXmlChildAutoSpaceDN(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildAutoSpaceDN) or {self.}XmlChildAutoSpaceDN.Removed) then
    begin
        {self.}XmlChildAutoSpaceDN := new PureWVal(self, {self.}Prefix, "autoSpaceDN");
        container_.Set({self.}XmlChildAutoSpaceDN);
    end
    return {self.}XmlChildAutoSpaceDN and not {self.}XmlChildAutoSpaceDN.Removed ? {self.}XmlChildAutoSpaceDN : fallback_.XmlChildAutoSpaceDN;
end;

function PPr.WriteXmlChildAutoSpaceDN(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildAutoSpaceDN) then
            {self.}RemoveChild({self.}XmlChildAutoSpaceDN);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildAutoSpaceDN := v;
        container_.Set({self.}XmlChildAutoSpaceDN);
    end
    else begin
        raise "Invalid assignment: AutoSpaceDN expects PureWVal or nil";
    end
end;

function PPr.ReadXmlChildRPr(): RPr;
begin
    if tslassigning and (ifnil({self.}XmlChildRPr) or {self.}XmlChildRPr.Removed) then
    begin
        {self.}XmlChildRPr := new RPr(self, {self.}Prefix, "rPr");
        container_.Set({self.}XmlChildRPr);
    end
    return {self.}XmlChildRPr and not {self.}XmlChildRPr.Removed ? {self.}XmlChildRPr : fallback_.XmlChildRPr;
end;

function PPr.WriteXmlChildRPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRPr) then
            {self.}RemoveChild({self.}XmlChildRPr);
    end
    else if v is class(RPr) then
    begin
        {self.}XmlChildRPr := v;
        container_.Set({self.}XmlChildRPr);
    end
    else begin
        raise "Invalid assignment: RPr expects RPr or nil";
    end
end;

function PPr.ReadXmlChildPBdr(): PBdr;
begin
    if tslassigning and (ifnil({self.}XmlChildPBdr) or {self.}XmlChildPBdr.Removed) then
    begin
        {self.}XmlChildPBdr := new PBdr(self, {self.}Prefix, "pBdr");
        container_.Set({self.}XmlChildPBdr);
    end
    return {self.}XmlChildPBdr and not {self.}XmlChildPBdr.Removed ? {self.}XmlChildPBdr : fallback_.XmlChildPBdr;
end;

function PPr.WriteXmlChildPBdr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPBdr) then
            {self.}RemoveChild({self.}XmlChildPBdr);
    end
    else if v is class(PBdr) then
    begin
        {self.}XmlChildPBdr := v;
        container_.Set({self.}XmlChildPBdr);
    end
    else begin
        raise "Invalid assignment: PBdr expects PBdr or nil";
    end
end;

function PPr.ReadXmlChildShd(): Shd;
begin
    if tslassigning and (ifnil({self.}XmlChildShd) or {self.}XmlChildShd.Removed) then
    begin
        {self.}XmlChildShd := new Shd(self, {self.}Prefix, "shd");
        container_.Set({self.}XmlChildShd);
    end
    return {self.}XmlChildShd and not {self.}XmlChildShd.Removed ? {self.}XmlChildShd : fallback_.XmlChildShd;
end;

function PPr.WriteXmlChildShd(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildShd) then
            {self.}RemoveChild({self.}XmlChildShd);
    end
    else if v is class(Shd) then
    begin
        {self.}XmlChildShd := v;
        container_.Set({self.}XmlChildShd);
    end
    else begin
        raise "Invalid assignment: Shd expects Shd or nil";
    end
end;

function PPr.ReadXmlChildWordWrap(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildWordWrap) or {self.}XmlChildWordWrap.Removed) then
    begin
        {self.}XmlChildWordWrap := new PureWVal(self, {self.}Prefix, "wordWrap");
        container_.Set({self.}XmlChildWordWrap);
    end
    return {self.}XmlChildWordWrap and not {self.}XmlChildWordWrap.Removed ? {self.}XmlChildWordWrap : fallback_.XmlChildWordWrap;
end;

function PPr.WriteXmlChildWordWrap(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildWordWrap) then
            {self.}RemoveChild({self.}XmlChildWordWrap);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildWordWrap := v;
        container_.Set({self.}XmlChildWordWrap);
    end
    else begin
        raise "Invalid assignment: WordWrap expects PureWVal or nil";
    end
end;

function PPr.ReadXmlChildDivId(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildDivId) or {self.}XmlChildDivId.Removed) then
    begin
        {self.}XmlChildDivId := new PureWVal(self, {self.}Prefix, "divId");
        container_.Set({self.}XmlChildDivId);
    end
    return {self.}XmlChildDivId and not {self.}XmlChildDivId.Removed ? {self.}XmlChildDivId : fallback_.XmlChildDivId;
end;

function PPr.WriteXmlChildDivId(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildDivId) then
            {self.}RemoveChild({self.}XmlChildDivId);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildDivId := v;
        container_.Set({self.}XmlChildDivId);
    end
    else begin
        raise "Invalid assignment: DivId expects PureWVal or nil";
    end
end;

function PPr.ReadXmlChildCnfStyle(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildCnfStyle) or {self.}XmlChildCnfStyle.Removed) then
    begin
        {self.}XmlChildCnfStyle := new PureWVal(self, {self.}Prefix, "cnfStyle");
        container_.Set({self.}XmlChildCnfStyle);
    end
    return {self.}XmlChildCnfStyle and not {self.}XmlChildCnfStyle.Removed ? {self.}XmlChildCnfStyle : fallback_.XmlChildCnfStyle;
end;

function PPr.WriteXmlChildCnfStyle(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildCnfStyle) then
            {self.}RemoveChild({self.}XmlChildCnfStyle);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildCnfStyle := v;
        container_.Set({self.}XmlChildCnfStyle);
    end
    else begin
        raise "Invalid assignment: CnfStyle expects PureWVal or nil";
    end
end;

function PPr.ReadXmlChildFramePr(): FramePr;
begin
    if tslassigning and (ifnil({self.}XmlChildFramePr) or {self.}XmlChildFramePr.Removed) then
    begin
        {self.}XmlChildFramePr := new FramePr(self, {self.}Prefix, "framePr");
        container_.Set({self.}XmlChildFramePr);
    end
    return {self.}XmlChildFramePr and not {self.}XmlChildFramePr.Removed ? {self.}XmlChildFramePr : fallback_.XmlChildFramePr;
end;

function PPr.WriteXmlChildFramePr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildFramePr) then
            {self.}RemoveChild({self.}XmlChildFramePr);
    end
    else if v is class(FramePr) then
    begin
        {self.}XmlChildFramePr := v;
        container_.Set({self.}XmlChildFramePr);
    end
    else begin
        raise "Invalid assignment: FramePr expects FramePr or nil";
    end
end;

function PPr.ReadXmlChildTextboxTightWrap(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildTextboxTightWrap) or {self.}XmlChildTextboxTightWrap.Removed) then
    begin
        {self.}XmlChildTextboxTightWrap := new PureWVal(self, {self.}Prefix, "textboxTightWrap");
        container_.Set({self.}XmlChildTextboxTightWrap);
    end
    return {self.}XmlChildTextboxTightWrap and not {self.}XmlChildTextboxTightWrap.Removed ? {self.}XmlChildTextboxTightWrap : fallback_.XmlChildTextboxTightWrap;
end;

function PPr.WriteXmlChildTextboxTightWrap(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTextboxTightWrap) then
            {self.}RemoveChild({self.}XmlChildTextboxTightWrap);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildTextboxTightWrap := v;
        container_.Set({self.}XmlChildTextboxTightWrap);
    end
    else begin
        raise "Invalid assignment: TextboxTightWrap expects PureWVal or nil";
    end
end;

function PPr.ReadXmlChildTopLinePunct(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildTopLinePunct) or {self.}XmlChildTopLinePunct.Removed) then
    begin
        {self.}XmlChildTopLinePunct := new PureWVal(self, {self.}Prefix, "topLinePunct");
        container_.Set({self.}XmlChildTopLinePunct);
    end
    return {self.}XmlChildTopLinePunct and not {self.}XmlChildTopLinePunct.Removed ? {self.}XmlChildTopLinePunct : fallback_.XmlChildTopLinePunct;
end;

function PPr.WriteXmlChildTopLinePunct(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTopLinePunct) then
            {self.}RemoveChild({self.}XmlChildTopLinePunct);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildTopLinePunct := v;
        container_.Set({self.}XmlChildTopLinePunct);
    end
    else begin
        raise "Invalid assignment: TopLinePunct expects PureWVal or nil";
    end
end;

function PPr.ReadXmlChildTextAlignment(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildTextAlignment) or {self.}XmlChildTextAlignment.Removed) then
    begin
        {self.}XmlChildTextAlignment := new PureWVal(self, {self.}Prefix, "textAlignment");
        container_.Set({self.}XmlChildTextAlignment);
    end
    return {self.}XmlChildTextAlignment and not {self.}XmlChildTextAlignment.Removed ? {self.}XmlChildTextAlignment : fallback_.XmlChildTextAlignment;
end;

function PPr.WriteXmlChildTextAlignment(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTextAlignment) then
            {self.}RemoveChild({self.}XmlChildTextAlignment);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildTextAlignment := v;
        container_.Set({self.}XmlChildTextAlignment);
    end
    else begin
        raise "Invalid assignment: TextAlignment expects PureWVal or nil";
    end
end;

function PPr.ReadXmlChildTextDirection(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildTextDirection) or {self.}XmlChildTextDirection.Removed) then
    begin
        {self.}XmlChildTextDirection := new PureWVal(self, {self.}Prefix, "textDirection");
        container_.Set({self.}XmlChildTextDirection);
    end
    return {self.}XmlChildTextDirection and not {self.}XmlChildTextDirection.Removed ? {self.}XmlChildTextDirection : fallback_.XmlChildTextDirection;
end;

function PPr.WriteXmlChildTextDirection(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTextDirection) then
            {self.}RemoveChild({self.}XmlChildTextDirection);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildTextDirection := v;
        container_.Set({self.}XmlChildTextDirection);
    end
    else begin
        raise "Invalid assignment: TextDirection expects PureWVal or nil";
    end
end;

function PPr.ReadXmlChildCollapsed(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildCollapsed) or {self.}XmlChildCollapsed.Removed) then
    begin
        {self.}XmlChildCollapsed := new PureWVal(self, "w15", "wordWrap");
        container_.Set({self.}XmlChildCollapsed);
    end
    return {self.}XmlChildCollapsed and not {self.}XmlChildCollapsed.Removed ? {self.}XmlChildCollapsed : fallback_.XmlChildCollapsed;
end;

function PPr.WriteXmlChildCollapsed(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildCollapsed) then
            {self.}RemoveChild({self.}XmlChildCollapsed);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildCollapsed := v;
        container_.Set({self.}XmlChildCollapsed);
    end
    else begin
        raise "Invalid assignment: Collapsed expects PureWVal or nil";
    end
end;

function PBdr.Create();overload;
begin
    {self.}Create(nil, "w", "pBdr");
end;

function PBdr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function PBdr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function PBdr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "top": array(0, makeweakref(thisFunction(ReadXmlChildTop))),
        pre + "left": array(1, makeweakref(thisFunction(ReadXmlChildLeft))),
        pre + "right": array(2, makeweakref(thisFunction(ReadXmlChildRight))),
        pre + "bottom": array(3, makeweakref(thisFunction(ReadXmlChildBottom))),
        pre + "between": array(4, makeweakref(thisFunction(ReadXmlChildBetween))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function PBdr.Copy(_obj: PBdr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildTop) then
        {self.}Top.Copy(_obj.XmlChildTop);
    if not ifnil(_obj.XmlChildLeft) then
        {self.}Left.Copy(_obj.XmlChildLeft);
    if not ifnil(_obj.XmlChildRight) then
        {self.}Right.Copy(_obj.XmlChildRight);
    if not ifnil(_obj.XmlChildBottom) then
        {self.}Bottom.Copy(_obj.XmlChildBottom);
    if not ifnil(_obj.XmlChildBetween) then
        {self.}Between.Copy(_obj.XmlChildBetween);
    tslassigning := tslassigning_backup;
end;

function PBdr.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildTop) then
        {self.}XmlChildTop.ConvertToPoint();
    if not ifnil({self.}XmlChildLeft) then
        {self.}XmlChildLeft.ConvertToPoint();
    if not ifnil({self.}XmlChildRight) then
        {self.}XmlChildRight.ConvertToPoint();
    if not ifnil({self.}XmlChildBottom) then
        {self.}XmlChildBottom.ConvertToPoint();
    if not ifnil({self.}XmlChildBetween) then
        {self.}XmlChildBetween.ConvertToPoint();
end;

function PBdr.ReadXmlChildTop(): PBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildTop) or {self.}XmlChildTop.Removed) then
    begin
        {self.}XmlChildTop := new PBorder(self, {self.}Prefix, "top");
        container_.Set({self.}XmlChildTop);
    end
    return {self.}XmlChildTop and not {self.}XmlChildTop.Removed ? {self.}XmlChildTop : fallback_.XmlChildTop;
end;

function PBdr.WriteXmlChildTop(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTop) then
            {self.}RemoveChild({self.}XmlChildTop);
    end
    else if v is class(PBorder) then
    begin
        {self.}XmlChildTop := v;
        container_.Set({self.}XmlChildTop);
    end
    else begin
        raise "Invalid assignment: Top expects PBorder or nil";
    end
end;

function PBdr.ReadXmlChildLeft(): PBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildLeft) or {self.}XmlChildLeft.Removed) then
    begin
        {self.}XmlChildLeft := new PBorder(self, {self.}Prefix, "left");
        container_.Set({self.}XmlChildLeft);
    end
    return {self.}XmlChildLeft and not {self.}XmlChildLeft.Removed ? {self.}XmlChildLeft : fallback_.XmlChildLeft;
end;

function PBdr.WriteXmlChildLeft(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildLeft) then
            {self.}RemoveChild({self.}XmlChildLeft);
    end
    else if v is class(PBorder) then
    begin
        {self.}XmlChildLeft := v;
        container_.Set({self.}XmlChildLeft);
    end
    else begin
        raise "Invalid assignment: Left expects PBorder or nil";
    end
end;

function PBdr.ReadXmlChildRight(): PBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildRight) or {self.}XmlChildRight.Removed) then
    begin
        {self.}XmlChildRight := new PBorder(self, {self.}Prefix, "right");
        container_.Set({self.}XmlChildRight);
    end
    return {self.}XmlChildRight and not {self.}XmlChildRight.Removed ? {self.}XmlChildRight : fallback_.XmlChildRight;
end;

function PBdr.WriteXmlChildRight(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRight) then
            {self.}RemoveChild({self.}XmlChildRight);
    end
    else if v is class(PBorder) then
    begin
        {self.}XmlChildRight := v;
        container_.Set({self.}XmlChildRight);
    end
    else begin
        raise "Invalid assignment: Right expects PBorder or nil";
    end
end;

function PBdr.ReadXmlChildBottom(): PBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildBottom) or {self.}XmlChildBottom.Removed) then
    begin
        {self.}XmlChildBottom := new PBorder(self, {self.}Prefix, "bottom");
        container_.Set({self.}XmlChildBottom);
    end
    return {self.}XmlChildBottom and not {self.}XmlChildBottom.Removed ? {self.}XmlChildBottom : fallback_.XmlChildBottom;
end;

function PBdr.WriteXmlChildBottom(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildBottom) then
            {self.}RemoveChild({self.}XmlChildBottom);
    end
    else if v is class(PBorder) then
    begin
        {self.}XmlChildBottom := v;
        container_.Set({self.}XmlChildBottom);
    end
    else begin
        raise "Invalid assignment: Bottom expects PBorder or nil";
    end
end;

function PBdr.ReadXmlChildBetween(): PBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildBetween) or {self.}XmlChildBetween.Removed) then
    begin
        {self.}XmlChildBetween := new PBorder(self, {self.}Prefix, "between");
        container_.Set({self.}XmlChildBetween);
    end
    return {self.}XmlChildBetween and not {self.}XmlChildBetween.Removed ? {self.}XmlChildBetween : fallback_.XmlChildBetween;
end;

function PBdr.WriteXmlChildBetween(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildBetween) then
            {self.}RemoveChild({self.}XmlChildBetween);
    end
    else if v is class(PBorder) then
    begin
        {self.}XmlChildBetween := v;
        container_.Set({self.}XmlChildBetween);
    end
    else begin
        raise "Invalid assignment: Between expects PBorder or nil";
    end
end;

function FramePr.Create();overload;
begin
    {self.}Create(nil, "w", "framePr");
end;

function FramePr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function FramePr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function FramePr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "anchorLock": makeweakref(thisFunction(WriteXmlAttrAnchorLock)),
        pre + "dropCap": makeweakref(thisFunction(WriteXmlAttrDropCap)),
        pre + "vAnchor": makeweakref(thisFunction(WriteXmlAttrVAnchor)),
        pre + "hAnchor": makeweakref(thisFunction(WriteXmlAttrHAnchor)),
        pre + "hRule": makeweakref(thisFunction(WriteXmlAttrHRule)),
        pre + "hSpace": makeweakref(thisFunction(WriteXmlAttrHSpace)),
        pre + "vSpace": makeweakref(thisFunction(WriteXmlAttrVSpace)),
        pre + "lines": makeweakref(thisFunction(WriteXmlAttrLines)),
        pre + "wrap": makeweakref(thisFunction(WriteXmlAttrWrap)),
        pre + "val": makeweakref(thisFunction(WriteXmlAttrVal)),
        pre + "w": makeweakref(thisFunction(WriteXmlAttrW)),
        pre + "h": makeweakref(thisFunction(WriteXmlAttrH)),
        pre + "x": makeweakref(thisFunction(WriteXmlAttrX)),
        pre + "y": makeweakref(thisFunction(WriteXmlAttrY)),
        pre + "xAlign": makeweakref(thisFunction(WriteXmlAttrXAlign)),
        pre + "yAlign": makeweakref(thisFunction(WriteXmlAttrYAlign)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function FramePr.Copy(_obj: FramePr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.AnchorLock) then
        {self.}AnchorLock := _obj.AnchorLock;
    if not ifnil(_obj.DropCap) then
        {self.}DropCap := _obj.DropCap;
    if not ifnil(_obj.VAnchor) then
        {self.}VAnchor := _obj.VAnchor;
    if not ifnil(_obj.HAnchor) then
        {self.}HAnchor := _obj.HAnchor;
    if not ifnil(_obj.HRule) then
        {self.}HRule := _obj.HRule;
    if not ifnil(_obj.HSpace) then
        {self.}HSpace := _obj.HSpace;
    if not ifnil(_obj.VSpace) then
        {self.}VSpace := _obj.VSpace;
    if not ifnil(_obj.Lines) then
        {self.}Lines := _obj.Lines;
    if not ifnil(_obj.Wrap) then
        {self.}Wrap := _obj.Wrap;
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    if not ifnil(_obj.W) then
        {self.}W := _obj.W;
    if not ifnil(_obj.H) then
        {self.}H := _obj.H;
    if not ifnil(_obj.X) then
        {self.}X := _obj.X;
    if not ifnil(_obj.Y) then
        {self.}Y := _obj.Y;
    if not ifnil(_obj.XAlign) then
        {self.}XAlign := _obj.XAlign;
    if not ifnil(_obj.YAlign) then
        {self.}YAlign := _obj.YAlign;
    tslassigning := tslassigning_backup;
end;

function FramePr.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrW) then
        {self.}W := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrW.Value);
    if not ifnil({self.}XmlAttrH) then
        {self.}H := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrH.Value);
end;

function FramePr.ReadXmlAttrAnchorLock();
begin
    return ifnil({self.}XmlAttrAnchorLock.Value) ? fallback_.XmlAttrAnchorLock.Value : {self.}XmlAttrAnchorLock.Value;
end;

function FramePr.WriteXmlAttrAnchorLock(_value: any);
begin
    if ifnil({self.}XmlAttrAnchorLock) then
    begin
        {self.}XmlAttrAnchorLock := new OpenXmlAttribute({self.}Prefix, "anchorLock", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "anchorLock" : "anchorLock"] := {self.}XmlAttrAnchorLock;
    end
    {self.}XmlAttrAnchorLock.Value := _value;
end;

function FramePr.ReadXmlAttrDropCap();
begin
    return ifnil({self.}XmlAttrDropCap.Value) ? fallback_.XmlAttrDropCap.Value : {self.}XmlAttrDropCap.Value;
end;

function FramePr.WriteXmlAttrDropCap(_value: any);
begin
    if ifnil({self.}XmlAttrDropCap) then
    begin
        {self.}XmlAttrDropCap := new OpenXmlAttribute({self.}Prefix, "dropCap", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "dropCap" : "dropCap"] := {self.}XmlAttrDropCap;
    end
    {self.}XmlAttrDropCap.Value := _value;
end;

function FramePr.ReadXmlAttrVAnchor();
begin
    return ifnil({self.}XmlAttrVAnchor.Value) ? fallback_.XmlAttrVAnchor.Value : {self.}XmlAttrVAnchor.Value;
end;

function FramePr.WriteXmlAttrVAnchor(_value: any);
begin
    if ifnil({self.}XmlAttrVAnchor) then
    begin
        {self.}XmlAttrVAnchor := new OpenXmlAttribute({self.}Prefix, "vAnchor", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "vAnchor" : "vAnchor"] := {self.}XmlAttrVAnchor;
    end
    {self.}XmlAttrVAnchor.Value := _value;
end;

function FramePr.ReadXmlAttrHAnchor();
begin
    return ifnil({self.}XmlAttrHAnchor.Value) ? fallback_.XmlAttrHAnchor.Value : {self.}XmlAttrHAnchor.Value;
end;

function FramePr.WriteXmlAttrHAnchor(_value: any);
begin
    if ifnil({self.}XmlAttrHAnchor) then
    begin
        {self.}XmlAttrHAnchor := new OpenXmlAttribute({self.}Prefix, "hAnchor", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "hAnchor" : "hAnchor"] := {self.}XmlAttrHAnchor;
    end
    {self.}XmlAttrHAnchor.Value := _value;
end;

function FramePr.ReadXmlAttrHRule();
begin
    return ifnil({self.}XmlAttrHRule.Value) ? fallback_.XmlAttrHRule.Value : {self.}XmlAttrHRule.Value;
end;

function FramePr.WriteXmlAttrHRule(_value: any);
begin
    if ifnil({self.}XmlAttrHRule) then
    begin
        {self.}XmlAttrHRule := new OpenXmlAttribute({self.}Prefix, "hRule", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "hRule" : "hRule"] := {self.}XmlAttrHRule;
    end
    {self.}XmlAttrHRule.Value := _value;
end;

function FramePr.ReadXmlAttrHSpace();
begin
    return ifnil({self.}XmlAttrHSpace.Value) ? fallback_.XmlAttrHSpace.Value : {self.}XmlAttrHSpace.Value;
end;

function FramePr.WriteXmlAttrHSpace(_value: any);
begin
    if ifnil({self.}XmlAttrHSpace) then
    begin
        {self.}XmlAttrHSpace := new OpenXmlAttribute({self.}Prefix, "hSpace", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "hSpace" : "hSpace"] := {self.}XmlAttrHSpace;
    end
    {self.}XmlAttrHSpace.Value := _value;
end;

function FramePr.ReadXmlAttrVSpace();
begin
    return ifnil({self.}XmlAttrVSpace.Value) ? fallback_.XmlAttrVSpace.Value : {self.}XmlAttrVSpace.Value;
end;

function FramePr.WriteXmlAttrVSpace(_value: any);
begin
    if ifnil({self.}XmlAttrVSpace) then
    begin
        {self.}XmlAttrVSpace := new OpenXmlAttribute({self.}Prefix, "vSpace", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "vSpace" : "vSpace"] := {self.}XmlAttrVSpace;
    end
    {self.}XmlAttrVSpace.Value := _value;
end;

function FramePr.ReadXmlAttrLines();
begin
    return ifnil({self.}XmlAttrLines.Value) ? fallback_.XmlAttrLines.Value : {self.}XmlAttrLines.Value;
end;

function FramePr.WriteXmlAttrLines(_value: any);
begin
    if ifnil({self.}XmlAttrLines) then
    begin
        {self.}XmlAttrLines := new OpenXmlAttribute({self.}Prefix, "lines", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "lines" : "lines"] := {self.}XmlAttrLines;
    end
    {self.}XmlAttrLines.Value := _value;
end;

function FramePr.ReadXmlAttrWrap();
begin
    return ifnil({self.}XmlAttrWrap.Value) ? fallback_.XmlAttrWrap.Value : {self.}XmlAttrWrap.Value;
end;

function FramePr.WriteXmlAttrWrap(_value: any);
begin
    if ifnil({self.}XmlAttrWrap) then
    begin
        {self.}XmlAttrWrap := new OpenXmlAttribute({self.}Prefix, "wrap", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "wrap" : "wrap"] := {self.}XmlAttrWrap;
    end
    {self.}XmlAttrWrap.Value := _value;
end;

function FramePr.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function FramePr.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute({self.}Prefix, "val", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "val" : "val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function FramePr.ReadXmlAttrW();
begin
    return ifnil({self.}XmlAttrW.Value) ? fallback_.XmlAttrW.Value : {self.}XmlAttrW.Value;
end;

function FramePr.WriteXmlAttrW(_value: any);
begin
    if ifnil({self.}XmlAttrW) then
    begin
        {self.}XmlAttrW := new OpenXmlAttribute({self.}Prefix, "w", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "w" : "w"] := {self.}XmlAttrW;
    end
    {self.}XmlAttrW.Value := _value;
end;

function FramePr.ReadXmlAttrH();
begin
    return ifnil({self.}XmlAttrH.Value) ? fallback_.XmlAttrH.Value : {self.}XmlAttrH.Value;
end;

function FramePr.WriteXmlAttrH(_value: any);
begin
    if ifnil({self.}XmlAttrH) then
    begin
        {self.}XmlAttrH := new OpenXmlAttribute({self.}Prefix, "h", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "h" : "h"] := {self.}XmlAttrH;
    end
    {self.}XmlAttrH.Value := _value;
end;

function FramePr.ReadXmlAttrX();
begin
    return ifnil({self.}XmlAttrX.Value) ? fallback_.XmlAttrX.Value : {self.}XmlAttrX.Value;
end;

function FramePr.WriteXmlAttrX(_value: any);
begin
    if ifnil({self.}XmlAttrX) then
    begin
        {self.}XmlAttrX := new OpenXmlAttribute({self.}Prefix, "x", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "x" : "x"] := {self.}XmlAttrX;
    end
    {self.}XmlAttrX.Value := _value;
end;

function FramePr.ReadXmlAttrY();
begin
    return ifnil({self.}XmlAttrY.Value) ? fallback_.XmlAttrY.Value : {self.}XmlAttrY.Value;
end;

function FramePr.WriteXmlAttrY(_value: any);
begin
    if ifnil({self.}XmlAttrY) then
    begin
        {self.}XmlAttrY := new OpenXmlAttribute({self.}Prefix, "y", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "y" : "y"] := {self.}XmlAttrY;
    end
    {self.}XmlAttrY.Value := _value;
end;

function FramePr.ReadXmlAttrXAlign();
begin
    return ifnil({self.}XmlAttrXAlign.Value) ? fallback_.XmlAttrXAlign.Value : {self.}XmlAttrXAlign.Value;
end;

function FramePr.WriteXmlAttrXAlign(_value: any);
begin
    if ifnil({self.}XmlAttrXAlign) then
    begin
        {self.}XmlAttrXAlign := new OpenXmlAttribute({self.}Prefix, "xAlign", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "xAlign" : "xAlign"] := {self.}XmlAttrXAlign;
    end
    {self.}XmlAttrXAlign.Value := _value;
end;

function FramePr.ReadXmlAttrYAlign();
begin
    return ifnil({self.}XmlAttrYAlign.Value) ? fallback_.XmlAttrYAlign.Value : {self.}XmlAttrYAlign.Value;
end;

function FramePr.WriteXmlAttrYAlign(_value: any);
begin
    if ifnil({self.}XmlAttrYAlign) then
    begin
        {self.}XmlAttrYAlign := new OpenXmlAttribute({self.}Prefix, "yAlign", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "yAlign" : "yAlign"] := {self.}XmlAttrYAlign;
    end
    {self.}XmlAttrYAlign.Value := _value;
end;

function PBorder.Create();overload;
begin
    {self.}Create(nil, "w", "");
end;

function PBorder.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function PBorder.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function PBorder.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "val": makeweakref(thisFunction(WriteXmlAttrVal)),
        pre + "color": makeweakref(thisFunction(WriteXmlAttrColor)),
        pre + "space": makeweakref(thisFunction(WriteXmlAttrSpace)),
        pre + "frame": makeweakref(thisFunction(WriteXmlAttrFrame)),
        pre + "shadow": makeweakref(thisFunction(WriteXmlAttrShadow)),
        pre + "themeColor": makeweakref(thisFunction(WriteXmlAttrThemeColor)),
        pre + "themeShade": makeweakref(thisFunction(WriteXmlAttrThemeShade)),
        pre + "themeTint": makeweakref(thisFunction(WriteXmlAttrThemeTint)),
        pre + "sz": makeweakref(thisFunction(WriteXmlAttrSz)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function PBorder.Copy(_obj: PBorder);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    if not ifnil(_obj.Color) then
        {self.}Color := _obj.Color;
    if not ifnil(_obj.Space) then
        {self.}Space := _obj.Space;
    if not ifnil(_obj.Frame) then
        {self.}Frame := _obj.Frame;
    if not ifnil(_obj.Shadow) then
        {self.}Shadow := _obj.Shadow;
    if not ifnil(_obj.ThemeColor) then
        {self.}ThemeColor := _obj.ThemeColor;
    if not ifnil(_obj.ThemeShade) then
        {self.}ThemeShade := _obj.ThemeShade;
    if not ifnil(_obj.ThemeTint) then
        {self.}ThemeTint := _obj.ThemeTint;
    if not ifnil(_obj.Sz) then
        {self.}Sz := _obj.Sz;
    tslassigning := tslassigning_backup;
end;

function PBorder.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrSz) then
        {self.}Sz := TSSafeUnitConverter.HalfPointToPoints({self.}XmlAttrSz.Value);
end;

function PBorder.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function PBorder.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute({self.}Prefix, "val", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "val" : "val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function PBorder.ReadXmlAttrColor();
begin
    return ifnil({self.}XmlAttrColor.Value) ? fallback_.XmlAttrColor.Value : {self.}XmlAttrColor.Value;
end;

function PBorder.WriteXmlAttrColor(_value: any);
begin
    if ifnil({self.}XmlAttrColor) then
    begin
        {self.}XmlAttrColor := new OpenXmlAttribute({self.}Prefix, "color", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "color" : "color"] := {self.}XmlAttrColor;
    end
    {self.}XmlAttrColor.Value := _value;
end;

function PBorder.ReadXmlAttrSpace();
begin
    return ifnil({self.}XmlAttrSpace.Value) ? fallback_.XmlAttrSpace.Value : {self.}XmlAttrSpace.Value;
end;

function PBorder.WriteXmlAttrSpace(_value: any);
begin
    if ifnil({self.}XmlAttrSpace) then
    begin
        {self.}XmlAttrSpace := new OpenXmlAttribute({self.}Prefix, "space", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "space" : "space"] := {self.}XmlAttrSpace;
    end
    {self.}XmlAttrSpace.Value := _value;
end;

function PBorder.ReadXmlAttrFrame();
begin
    return ifnil({self.}XmlAttrFrame.Value) ? fallback_.XmlAttrFrame.Value : {self.}XmlAttrFrame.Value;
end;

function PBorder.WriteXmlAttrFrame(_value: any);
begin
    if ifnil({self.}XmlAttrFrame) then
    begin
        {self.}XmlAttrFrame := new OpenXmlAttribute({self.}Prefix, "frame", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "frame" : "frame"] := {self.}XmlAttrFrame;
    end
    {self.}XmlAttrFrame.Value := _value;
end;

function PBorder.ReadXmlAttrShadow();
begin
    return ifnil({self.}XmlAttrShadow.Value) ? fallback_.XmlAttrShadow.Value : {self.}XmlAttrShadow.Value;
end;

function PBorder.WriteXmlAttrShadow(_value: any);
begin
    if ifnil({self.}XmlAttrShadow) then
    begin
        {self.}XmlAttrShadow := new OpenXmlAttribute({self.}Prefix, "shadow", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "shadow" : "shadow"] := {self.}XmlAttrShadow;
    end
    {self.}XmlAttrShadow.Value := _value;
end;

function PBorder.ReadXmlAttrThemeColor();
begin
    return ifnil({self.}XmlAttrThemeColor.Value) ? fallback_.XmlAttrThemeColor.Value : {self.}XmlAttrThemeColor.Value;
end;

function PBorder.WriteXmlAttrThemeColor(_value: any);
begin
    if ifnil({self.}XmlAttrThemeColor) then
    begin
        {self.}XmlAttrThemeColor := new OpenXmlAttribute({self.}Prefix, "themeColor", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeColor" : "themeColor"] := {self.}XmlAttrThemeColor;
    end
    {self.}XmlAttrThemeColor.Value := _value;
end;

function PBorder.ReadXmlAttrThemeShade();
begin
    return ifnil({self.}XmlAttrThemeShade.Value) ? fallback_.XmlAttrThemeShade.Value : {self.}XmlAttrThemeShade.Value;
end;

function PBorder.WriteXmlAttrThemeShade(_value: any);
begin
    if ifnil({self.}XmlAttrThemeShade) then
    begin
        {self.}XmlAttrThemeShade := new OpenXmlAttribute({self.}Prefix, "themeShade", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeShade" : "themeShade"] := {self.}XmlAttrThemeShade;
    end
    {self.}XmlAttrThemeShade.Value := _value;
end;

function PBorder.ReadXmlAttrThemeTint();
begin
    return ifnil({self.}XmlAttrThemeTint.Value) ? fallback_.XmlAttrThemeTint.Value : {self.}XmlAttrThemeTint.Value;
end;

function PBorder.WriteXmlAttrThemeTint(_value: any);
begin
    if ifnil({self.}XmlAttrThemeTint) then
    begin
        {self.}XmlAttrThemeTint := new OpenXmlAttribute({self.}Prefix, "themeTint", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeTint" : "themeTint"] := {self.}XmlAttrThemeTint;
    end
    {self.}XmlAttrThemeTint.Value := _value;
end;

function PBorder.ReadXmlAttrSz();
begin
    return ifnil({self.}XmlAttrSz.Value) ? fallback_.XmlAttrSz.Value : {self.}XmlAttrSz.Value;
end;

function PBorder.WriteXmlAttrSz(_value: any);
begin
    if ifnil({self.}XmlAttrSz) then
    begin
        {self.}XmlAttrSz := new OpenXmlAttribute({self.}Prefix, "sz", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "sz" : "sz"] := {self.}XmlAttrSz;
    end
    {self.}XmlAttrSz.Value := _value;
end;

function Tabs.Create();overload;
begin
    {self.}Create(nil, "w", "tabs");
end;

function Tabs.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Tabs.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Tabs.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "tab": array(0, makeweakref(thisFunction(AppendTab))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Tabs.Copy(_obj: Tabs);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    tslassigning := tslassigning_backup;
end;

function Tabs.ConvertToPoint();override;
begin
    elems := {self.}Tabs();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Tabs.ReadTabs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "tab", ind);
end;

function Tabs.WriteTabs(_index: integer; _value: nil_OR_Tab);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadTabs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "tab", ind, _value) then
            raise format("Index out of range: Tabs[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Tabs expects nil or Tab";
    end
end;

function Tabs.AddTab(): Tab;
begin
    obj := new Tab(self, {self.}Prefix, "tab");
    container_.Insert(obj);
    return obj;
end;

function Tabs.AppendTab(): Tab;
begin
    obj := new Tab(self, {self.}Prefix, "tab");
    container_.Append(obj);
    return obj;
end;

function Tab.Create();overload;
begin
    {self.}Create(nil, "w", "tab");
end;

function Tab.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Tab.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Tab.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "val": makeweakref(thisFunction(WriteXmlAttrVal)),
        pre + "leader": makeweakref(thisFunction(WriteXmlAttrLeader)),
        pre + "pos": makeweakref(thisFunction(WriteXmlAttrPos)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Tab.Copy(_obj: Tab);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    if not ifnil(_obj.Leader) then
        {self.}Leader := _obj.Leader;
    if not ifnil(_obj.Pos) then
        {self.}Pos := _obj.Pos;
    tslassigning := tslassigning_backup;
end;

function Tab.ConvertToPoint();override;
begin

end;

function Tab.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function Tab.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute("", "val", nil);
        attributes_["val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function Tab.ReadXmlAttrLeader();
begin
    return ifnil({self.}XmlAttrLeader.Value) ? fallback_.XmlAttrLeader.Value : {self.}XmlAttrLeader.Value;
end;

function Tab.WriteXmlAttrLeader(_value: any);
begin
    if ifnil({self.}XmlAttrLeader) then
    begin
        {self.}XmlAttrLeader := new OpenXmlAttribute({self.}Prefix, "leader", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "leader" : "leader"] := {self.}XmlAttrLeader;
    end
    {self.}XmlAttrLeader.Value := _value;
end;

function Tab.ReadXmlAttrPos();
begin
    return ifnil({self.}XmlAttrPos.Value) ? fallback_.XmlAttrPos.Value : {self.}XmlAttrPos.Value;
end;

function Tab.WriteXmlAttrPos(_value: any);
begin
    if ifnil({self.}XmlAttrPos) then
    begin
        {self.}XmlAttrPos := new OpenXmlAttribute({self.}Prefix, "pos", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "pos" : "pos"] := {self.}XmlAttrPos;
    end
    {self.}XmlAttrPos.Value := _value;
end;

function NumPr.Create();overload;
begin
    {self.}Create(nil, "w", "numPr");
end;

function NumPr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function NumPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function NumPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "ilvl": array(0, makeweakref(thisFunction(ReadXmlChildIlvl))),
        pre + "numId": array(1, makeweakref(thisFunction(ReadXmlChildNumId))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function NumPr.Copy(_obj: NumPr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildIlvl) then
        {self.}Ilvl.Copy(_obj.XmlChildIlvl);
    if not ifnil(_obj.XmlChildNumId) then
        {self.}NumId.Copy(_obj.XmlChildNumId);
    tslassigning := tslassigning_backup;
end;

function NumPr.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildIlvl) then
        {self.}XmlChildIlvl.ConvertToPoint();
    if not ifnil({self.}XmlChildNumId) then
        {self.}XmlChildNumId.ConvertToPoint();
end;

function NumPr.ReadXmlChildIlvl(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildIlvl) or {self.}XmlChildIlvl.Removed) then
    begin
        {self.}XmlChildIlvl := new PureWVal(self, {self.}Prefix, "ilvl");
        container_.Set({self.}XmlChildIlvl);
    end
    return {self.}XmlChildIlvl and not {self.}XmlChildIlvl.Removed ? {self.}XmlChildIlvl : fallback_.XmlChildIlvl;
end;

function NumPr.WriteXmlChildIlvl(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildIlvl) then
            {self.}RemoveChild({self.}XmlChildIlvl);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildIlvl := v;
        container_.Set({self.}XmlChildIlvl);
    end
    else begin
        raise "Invalid assignment: Ilvl expects PureWVal or nil";
    end
end;

function NumPr.ReadXmlChildNumId(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildNumId) or {self.}XmlChildNumId.Removed) then
    begin
        {self.}XmlChildNumId := new PureWVal(self, {self.}Prefix, "numId");
        container_.Set({self.}XmlChildNumId);
    end
    return {self.}XmlChildNumId and not {self.}XmlChildNumId.Removed ? {self.}XmlChildNumId : fallback_.XmlChildNumId;
end;

function NumPr.WriteXmlChildNumId(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildNumId) then
            {self.}RemoveChild({self.}XmlChildNumId);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildNumId := v;
        container_.Set({self.}XmlChildNumId);
    end
    else begin
        raise "Invalid assignment: NumId expects PureWVal or nil";
    end
end;

function Ind.Create();overload;
begin
    {self.}Create(nil, "w", "ind");
end;

function Ind.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Ind.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Ind.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "firstLineChars": makeweakref(thisFunction(WriteXmlAttrFirstLineChars)),
        pre + "firstLine": makeweakref(thisFunction(WriteXmlAttrFirstLine)),
        pre + "rightChars": makeweakref(thisFunction(WriteXmlAttrRightChars)),
        pre + "right": makeweakref(thisFunction(WriteXmlAttrRight)),
        pre + "leftChars": makeweakref(thisFunction(WriteXmlAttrLeftChars)),
        pre + "left": makeweakref(thisFunction(WriteXmlAttrLeft)),
        pre + "hainging": makeweakref(thisFunction(WriteXmlAttrHanging)),
        pre + "hangingChars": makeweakref(thisFunction(WriteXmlAttrHangingChars)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Ind.Copy(_obj: Ind);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.FirstLineChars) then
        {self.}FirstLineChars := _obj.FirstLineChars;
    if not ifnil(_obj.FirstLine) then
        {self.}FirstLine := _obj.FirstLine;
    if not ifnil(_obj.RightChars) then
        {self.}RightChars := _obj.RightChars;
    if not ifnil(_obj.Right) then
        {self.}Right := _obj.Right;
    if not ifnil(_obj.LeftChars) then
        {self.}LeftChars := _obj.LeftChars;
    if not ifnil(_obj.Left) then
        {self.}Left := _obj.Left;
    if not ifnil(_obj.Hanging) then
        {self.}Hanging := _obj.Hanging;
    if not ifnil(_obj.HangingChars) then
        {self.}HangingChars := _obj.HangingChars;
    tslassigning := tslassigning_backup;
end;

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

function Ind.ReadXmlAttrFirstLineChars();
begin
    return ifnil({self.}XmlAttrFirstLineChars.Value) ? fallback_.XmlAttrFirstLineChars.Value : {self.}XmlAttrFirstLineChars.Value;
end;

function Ind.WriteXmlAttrFirstLineChars(_value: any);
begin
    if ifnil({self.}XmlAttrFirstLineChars) then
    begin
        {self.}XmlAttrFirstLineChars := new OpenXmlAttribute({self.}Prefix, "firstLineChars", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "firstLineChars" : "firstLineChars"] := {self.}XmlAttrFirstLineChars;
    end
    {self.}XmlAttrFirstLineChars.Value := _value;
end;

function Ind.ReadXmlAttrFirstLine();
begin
    return ifnil({self.}XmlAttrFirstLine.Value) ? fallback_.XmlAttrFirstLine.Value : {self.}XmlAttrFirstLine.Value;
end;

function Ind.WriteXmlAttrFirstLine(_value: any);
begin
    if ifnil({self.}XmlAttrFirstLine) then
    begin
        {self.}XmlAttrFirstLine := new OpenXmlAttribute({self.}Prefix, "firstLine", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "firstLine" : "firstLine"] := {self.}XmlAttrFirstLine;
    end
    {self.}XmlAttrFirstLine.Value := _value;
end;

function Ind.ReadXmlAttrRightChars();
begin
    return ifnil({self.}XmlAttrRightChars.Value) ? fallback_.XmlAttrRightChars.Value : {self.}XmlAttrRightChars.Value;
end;

function Ind.WriteXmlAttrRightChars(_value: any);
begin
    if ifnil({self.}XmlAttrRightChars) then
    begin
        {self.}XmlAttrRightChars := new OpenXmlAttribute({self.}Prefix, "rightChars", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "rightChars" : "rightChars"] := {self.}XmlAttrRightChars;
    end
    {self.}XmlAttrRightChars.Value := _value;
end;

function Ind.ReadXmlAttrRight();
begin
    return ifnil({self.}XmlAttrRight.Value) ? fallback_.XmlAttrRight.Value : {self.}XmlAttrRight.Value;
end;

function Ind.WriteXmlAttrRight(_value: any);
begin
    if ifnil({self.}XmlAttrRight) then
    begin
        {self.}XmlAttrRight := new OpenXmlAttribute({self.}Prefix, "right", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "right" : "right"] := {self.}XmlAttrRight;
    end
    {self.}XmlAttrRight.Value := _value;
end;

function Ind.ReadXmlAttrLeftChars();
begin
    return ifnil({self.}XmlAttrLeftChars.Value) ? fallback_.XmlAttrLeftChars.Value : {self.}XmlAttrLeftChars.Value;
end;

function Ind.WriteXmlAttrLeftChars(_value: any);
begin
    if ifnil({self.}XmlAttrLeftChars) then
    begin
        {self.}XmlAttrLeftChars := new OpenXmlAttribute({self.}Prefix, "leftChars", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "leftChars" : "leftChars"] := {self.}XmlAttrLeftChars;
    end
    {self.}XmlAttrLeftChars.Value := _value;
end;

function Ind.ReadXmlAttrLeft();
begin
    return ifnil({self.}XmlAttrLeft.Value) ? fallback_.XmlAttrLeft.Value : {self.}XmlAttrLeft.Value;
end;

function Ind.WriteXmlAttrLeft(_value: any);
begin
    if ifnil({self.}XmlAttrLeft) then
    begin
        {self.}XmlAttrLeft := new OpenXmlAttribute({self.}Prefix, "left", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "left" : "left"] := {self.}XmlAttrLeft;
    end
    {self.}XmlAttrLeft.Value := _value;
end;

function Ind.ReadXmlAttrHanging();
begin
    return ifnil({self.}XmlAttrHanging.Value) ? fallback_.XmlAttrHanging.Value : {self.}XmlAttrHanging.Value;
end;

function Ind.WriteXmlAttrHanging(_value: any);
begin
    if ifnil({self.}XmlAttrHanging) then
    begin
        {self.}XmlAttrHanging := new OpenXmlAttribute({self.}Prefix, "hainging", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "hainging" : "hainging"] := {self.}XmlAttrHanging;
    end
    {self.}XmlAttrHanging.Value := _value;
end;

function Ind.ReadXmlAttrHangingChars();
begin
    return ifnil({self.}XmlAttrHangingChars.Value) ? fallback_.XmlAttrHangingChars.Value : {self.}XmlAttrHangingChars.Value;
end;

function Ind.WriteXmlAttrHangingChars(_value: any);
begin
    if ifnil({self.}XmlAttrHangingChars) then
    begin
        {self.}XmlAttrHangingChars := new OpenXmlAttribute({self.}Prefix, "hangingChars", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "hangingChars" : "hangingChars"] := {self.}XmlAttrHangingChars;
    end
    {self.}XmlAttrHangingChars.Value := _value;
end;

function Spacing.Create();overload;
begin
    {self.}Create(nil, "w", "spacing");
end;

function Spacing.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Spacing.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Spacing.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "before": makeweakref(thisFunction(WriteXmlAttrBefore)),
        pre + "beforeLines": makeweakref(thisFunction(WriteXmlAttrBeforeLines)),
        pre + "beforeAutospacing": makeweakref(thisFunction(WriteXmlAttrBeforeAutospacing)),
        pre + "after": makeweakref(thisFunction(WriteXmlAttrAfter)),
        pre + "afterLines": makeweakref(thisFunction(WriteXmlAttrAfterLines)),
        pre + "afterAutospacing": makeweakref(thisFunction(WriteXmlAttrAfterAutospacing)),
        pre + "line": makeweakref(thisFunction(WriteXmlAttrLine)),
        pre + "lineRule": makeweakref(thisFunction(WriteXmlAttrLineRule)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Spacing.Copy(_obj: Spacing);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Before) then
        {self.}Before := _obj.Before;
    if not ifnil(_obj.BeforeLines) then
        {self.}BeforeLines := _obj.BeforeLines;
    if not ifnil(_obj.BeforeAutospacing) then
        {self.}BeforeAutospacing := _obj.BeforeAutospacing;
    if not ifnil(_obj.After) then
        {self.}After := _obj.After;
    if not ifnil(_obj.AfterLines) then
        {self.}AfterLines := _obj.AfterLines;
    if not ifnil(_obj.AfterAutospacing) then
        {self.}AfterAutospacing := _obj.AfterAutospacing;
    if not ifnil(_obj.Line) then
        {self.}Line := _obj.Line;
    if not ifnil(_obj.LineRule) then
        {self.}LineRule := _obj.LineRule;
    tslassigning := tslassigning_backup;
end;

function Spacing.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrBefore) then
        {self.}Before := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrBefore.Value);
    if not ifnil({self.}XmlAttrBeforeLines) then
        {self.}BeforeLines := TSSafeUnitConverter.PercentToNumber({self.}XmlAttrBeforeLines.Value);
    if not ifnil({self.}XmlAttrAfter) then
        {self.}After := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrAfter.Value);
    if not ifnil({self.}XmlAttrAfterLines) then
        {self.}AfterLines := TSSafeUnitConverter.PercentToNumber({self.}XmlAttrAfterLines.Value);
    if not ifnil({self.}XmlAttrLine) then
        {self.}Line := TSSafeUnitConverter.ToInt({self.}XmlAttrLine.Value);
end;

function Spacing.ReadXmlAttrBefore();
begin
    return ifnil({self.}XmlAttrBefore.Value) ? fallback_.XmlAttrBefore.Value : {self.}XmlAttrBefore.Value;
end;

function Spacing.WriteXmlAttrBefore(_value: any);
begin
    if ifnil({self.}XmlAttrBefore) then
    begin
        {self.}XmlAttrBefore := new OpenXmlAttribute({self.}Prefix, "before", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "before" : "before"] := {self.}XmlAttrBefore;
    end
    {self.}XmlAttrBefore.Value := _value;
end;

function Spacing.ReadXmlAttrBeforeLines();
begin
    return ifnil({self.}XmlAttrBeforeLines.Value) ? fallback_.XmlAttrBeforeLines.Value : {self.}XmlAttrBeforeLines.Value;
end;

function Spacing.WriteXmlAttrBeforeLines(_value: any);
begin
    if ifnil({self.}XmlAttrBeforeLines) then
    begin
        {self.}XmlAttrBeforeLines := new OpenXmlAttribute({self.}Prefix, "beforeLines", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "beforeLines" : "beforeLines"] := {self.}XmlAttrBeforeLines;
    end
    {self.}XmlAttrBeforeLines.Value := _value;
end;

function Spacing.ReadXmlAttrBeforeAutospacing();
begin
    return ifnil({self.}XmlAttrBeforeAutospacing.Value) ? fallback_.XmlAttrBeforeAutospacing.Value : {self.}XmlAttrBeforeAutospacing.Value;
end;

function Spacing.WriteXmlAttrBeforeAutospacing(_value: any);
begin
    if ifnil({self.}XmlAttrBeforeAutospacing) then
    begin
        {self.}XmlAttrBeforeAutospacing := new OpenXmlAttribute({self.}Prefix, "beforeAutospacing", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "beforeAutospacing" : "beforeAutospacing"] := {self.}XmlAttrBeforeAutospacing;
    end
    {self.}XmlAttrBeforeAutospacing.Value := _value;
end;

function Spacing.ReadXmlAttrAfter();
begin
    return ifnil({self.}XmlAttrAfter.Value) ? fallback_.XmlAttrAfter.Value : {self.}XmlAttrAfter.Value;
end;

function Spacing.WriteXmlAttrAfter(_value: any);
begin
    if ifnil({self.}XmlAttrAfter) then
    begin
        {self.}XmlAttrAfter := new OpenXmlAttribute({self.}Prefix, "after", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "after" : "after"] := {self.}XmlAttrAfter;
    end
    {self.}XmlAttrAfter.Value := _value;
end;

function Spacing.ReadXmlAttrAfterLines();
begin
    return ifnil({self.}XmlAttrAfterLines.Value) ? fallback_.XmlAttrAfterLines.Value : {self.}XmlAttrAfterLines.Value;
end;

function Spacing.WriteXmlAttrAfterLines(_value: any);
begin
    if ifnil({self.}XmlAttrAfterLines) then
    begin
        {self.}XmlAttrAfterLines := new OpenXmlAttribute({self.}Prefix, "afterLines", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "afterLines" : "afterLines"] := {self.}XmlAttrAfterLines;
    end
    {self.}XmlAttrAfterLines.Value := _value;
end;

function Spacing.ReadXmlAttrAfterAutospacing();
begin
    return ifnil({self.}XmlAttrAfterAutospacing.Value) ? fallback_.XmlAttrAfterAutospacing.Value : {self.}XmlAttrAfterAutospacing.Value;
end;

function Spacing.WriteXmlAttrAfterAutospacing(_value: any);
begin
    if ifnil({self.}XmlAttrAfterAutospacing) then
    begin
        {self.}XmlAttrAfterAutospacing := new OpenXmlAttribute({self.}Prefix, "afterAutospacing", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "afterAutospacing" : "afterAutospacing"] := {self.}XmlAttrAfterAutospacing;
    end
    {self.}XmlAttrAfterAutospacing.Value := _value;
end;

function Spacing.ReadXmlAttrLine();
begin
    return ifnil({self.}XmlAttrLine.Value) ? fallback_.XmlAttrLine.Value : {self.}XmlAttrLine.Value;
end;

function Spacing.WriteXmlAttrLine(_value: any);
begin
    if ifnil({self.}XmlAttrLine) then
    begin
        {self.}XmlAttrLine := new OpenXmlAttribute({self.}Prefix, "line", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "line" : "line"] := {self.}XmlAttrLine;
    end
    {self.}XmlAttrLine.Value := _value;
end;

function Spacing.ReadXmlAttrLineRule();
begin
    return ifnil({self.}XmlAttrLineRule.Value) ? fallback_.XmlAttrLineRule.Value : {self.}XmlAttrLineRule.Value;
end;

function Spacing.WriteXmlAttrLineRule(_value: any);
begin
    if ifnil({self.}XmlAttrLineRule) then
    begin
        {self.}XmlAttrLineRule := new OpenXmlAttribute({self.}Prefix, "lineRule", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "lineRule" : "lineRule"] := {self.}XmlAttrLineRule;
    end
    {self.}XmlAttrLineRule.Value := _value;
end;

function RPr.Create();overload;
begin
    {self.}Create(nil, "w", "rPr");
end;

function RPr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function RPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function RPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "noProof": array(0, makeweakref(thisFunction(ReadXmlChildNoProof))),
        pre + "outline": array(1, makeweakref(thisFunction(ReadXmlChildOutline))),
        pre + "position": array(2, makeweakref(thisFunction(ReadXmlChildPosition))),
        pre + "wedHidden": array(3, makeweakref(thisFunction(ReadXmlChildWebHidden))),
        pre + "rStyle": array(4, makeweakref(thisFunction(ReadXmlChildRStyle))),
        pre + "ins": array(5, makeweakref(thisFunction(ReadXmlChildIns))),
        pre + "rFonts": array(6, makeweakref(thisFunction(ReadXmlChildRFonts))),
        pre + "kern": array(7, makeweakref(thisFunction(ReadXmlChildKern))),
        pre + "i": array(8, makeweakref(thisFunction(ReadXmlChildI))),
        pre + "iCs": array(9, makeweakref(thisFunction(ReadXmlChildICs))),
        pre + "b": array(10, makeweakref(thisFunction(ReadXmlChildB))),
        pre + "bCs": array(11, makeweakref(thisFunction(ReadXmlChildBCs))),
        pre + "bdr": array(12, makeweakref(thisFunction(ReadXmlChildBdr))),
        pre + "caps": array(13, makeweakref(thisFunction(ReadXmlChildCaps))),
        pre + "del": array(14, makeweakref(thisFunction(ReadXmlChildDel))),
        pre + "strike": array(15, makeweakref(thisFunction(ReadXmlChildStrike))),
        pre + "dstrike": array(16, makeweakref(thisFunction(ReadXmlChildDStrike))),
        pre + "effect": array(17, makeweakref(thisFunction(ReadXmlChildEffect))),
        pre + "em": array(18, makeweakref(thisFunction(ReadXmlChildEm))),
        pre + "emboss": array(19, makeweakref(thisFunction(ReadXmlChildEmboss))),
        pre + "fitText": array(20, makeweakref(thisFunction(ReadXmlChildFitText))),
        pre + "highlight": array(21, makeweakref(thisFunction(ReadXmlChildHighlight))),
        pre + "color": array(22, makeweakref(thisFunction(ReadXmlChildColor))),
        pre + "eastAsianLayout": array(23, makeweakref(thisFunction(ReadXmlChildEastAsianLayout))),
        pre + "cs": array(24, makeweakref(thisFunction(ReadXmlChildCs))),
        pre + "sz": array(25, makeweakref(thisFunction(ReadXmlChildSz))),
        pre + "szCs": array(26, makeweakref(thisFunction(ReadXmlChildSzCs))),
        pre + "u": array(27, makeweakref(thisFunction(ReadXmlChildU))),
        pre + "lang": array(28, makeweakref(thisFunction(ReadXmlChildLang))),
        pre + "imprint": array(29, makeweakref(thisFunction(ReadXmlChildImprint))),
        pre + "vertAlign": array(30, makeweakref(thisFunction(ReadXmlChildVertAlign))),
        "w14:ligatures": array(31, makeweakref(thisFunction(ReadXmlChildLigatures))),
        pre + "rtl": array(32, makeweakref(thisFunction(ReadXmlChildRtl))),
        pre + "oMath": array(33, makeweakref(thisFunction(ReadXmlChildOMath))),
        pre + "shadow": array(34, makeweakref(thisFunction(ReadXmlChildShadow))),
        pre + "specVanish": array(35, makeweakref(thisFunction(ReadXmlChildSpecVanish))),
        pre + "vanish": array(36, makeweakref(thisFunction(ReadXmlChildVanish))),
        pre + "shd": array(37, makeweakref(thisFunction(ReadXmlChildShd))),
        pre + "smallCaps": array(38, makeweakref(thisFunction(ReadXmlChildSmallCaps))),
        pre + "w": array(39, makeweakref(thisFunction(ReadXmlChildW))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function RPr.Copy(_obj: RPr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildNoProof) then
        {self.}NoProof.Copy(_obj.XmlChildNoProof);
    if not ifnil(_obj.XmlChildOutline) then
        {self.}Outline.Copy(_obj.XmlChildOutline);
    if not ifnil(_obj.XmlChildPosition) then
        {self.}Position.Copy(_obj.XmlChildPosition);
    if not ifnil(_obj.XmlChildWebHidden) then
        {self.}WebHidden.Copy(_obj.XmlChildWebHidden);
    if not ifnil(_obj.XmlChildRStyle) then
        {self.}RStyle.Copy(_obj.XmlChildRStyle);
    if not ifnil(_obj.XmlChildIns) then
        {self.}Ins.Copy(_obj.XmlChildIns);
    if not ifnil(_obj.XmlChildRFonts) then
        {self.}RFonts.Copy(_obj.XmlChildRFonts);
    if not ifnil(_obj.XmlChildKern) then
        {self.}Kern.Copy(_obj.XmlChildKern);
    if not ifnil(_obj.XmlChildI) then
        ifnil({self.}XmlChildI) ? {self.}I.Copy(_obj.XmlChildI) : {self.}XmlChildI.Copy(_obj.XmlChildI);
    if not ifnil(_obj.XmlChildICs) then
        ifnil({self.}XmlChildICs) ? {self.}ICs.Copy(_obj.XmlChildICs) : {self.}XmlChildICs.Copy(_obj.XmlChildICs);
    if not ifnil(_obj.XmlChildB) then
        ifnil({self.}XmlChildB) ? {self.}B.Copy(_obj.XmlChildB) : {self.}XmlChildB.Copy(_obj.XmlChildB);
    if not ifnil(_obj.XmlChildBCs) then
        ifnil({self.}XmlChildBCs) ? {self.}BCs.Copy(_obj.XmlChildBCs) : {self.}XmlChildBCs.Copy(_obj.XmlChildBCs);
    if not ifnil(_obj.XmlChildBdr) then
        {self.}Bdr.Copy(_obj.XmlChildBdr);
    if not ifnil(_obj.XmlChildCaps) then
        {self.}Caps.Copy(_obj.XmlChildCaps);
    if not ifnil(_obj.XmlChildDel) then
        {self.}Del.Copy(_obj.XmlChildDel);
    if not ifnil(_obj.XmlChildStrike) then
        ifnil({self.}XmlChildStrike) ? {self.}Strike.Copy(_obj.XmlChildStrike) : {self.}XmlChildStrike.Copy(_obj.XmlChildStrike);
    if not ifnil(_obj.XmlChildDStrike) then
        {self.}DStrike.Copy(_obj.XmlChildDStrike);
    if not ifnil(_obj.XmlChildEffect) then
        {self.}Effect.Copy(_obj.XmlChildEffect);
    if not ifnil(_obj.XmlChildEm) then
        {self.}Em.Copy(_obj.XmlChildEm);
    if not ifnil(_obj.XmlChildEmboss) then
        {self.}Emboss.Copy(_obj.XmlChildEmboss);
    if not ifnil(_obj.XmlChildFitText) then
        {self.}FitText.Copy(_obj.XmlChildFitText);
    if not ifnil(_obj.XmlChildHighlight) then
        {self.}Highlight.Copy(_obj.XmlChildHighlight);
    if not ifnil(_obj.XmlChildColor) then
        {self.}Color.Copy(_obj.XmlChildColor);
    if not ifnil(_obj.XmlChildEastAsianLayout) then
        {self.}EastAsianLayout.Copy(_obj.XmlChildEastAsianLayout);
    if not ifnil(_obj.XmlChildCs) then
        ifnil({self.}XmlChildCs) ? {self.}Cs.Copy(_obj.XmlChildCs) : {self.}XmlChildCs.Copy(_obj.XmlChildCs);
    if not ifnil(_obj.XmlChildSz) then
        {self.}Sz.Copy(_obj.XmlChildSz);
    if not ifnil(_obj.XmlChildSzCs) then
        {self.}SzCs.Copy(_obj.XmlChildSzCs);
    if not ifnil(_obj.XmlChildU) then
        ifnil({self.}XmlChildU) ? {self.}U.Copy(_obj.XmlChildU) : {self.}XmlChildU.Copy(_obj.XmlChildU);
    if not ifnil(_obj.XmlChildLang) then
        {self.}Lang.Copy(_obj.XmlChildLang);
    if not ifnil(_obj.XmlChildImprint) then
        {self.}Imprint.Copy(_obj.XmlChildImprint);
    if not ifnil(_obj.XmlChildVertAlign) then
        {self.}VertAlign.Copy(_obj.XmlChildVertAlign);
    if not ifnil(_obj.XmlChildLigatures) then
        {self.}Ligatures.Copy(_obj.XmlChildLigatures);
    if not ifnil(_obj.XmlChildRtl) then
        {self.}Rtl.Copy(_obj.XmlChildRtl);
    if not ifnil(_obj.XmlChildOMath) then
        ifnil({self.}XmlChildOMath) ? {self.}OMath.Copy(_obj.XmlChildOMath) : {self.}XmlChildOMath.Copy(_obj.XmlChildOMath);
    if not ifnil(_obj.XmlChildShadow) then
        ifnil({self.}XmlChildShadow) ? {self.}Shadow.Copy(_obj.XmlChildShadow) : {self.}XmlChildShadow.Copy(_obj.XmlChildShadow);
    if not ifnil(_obj.XmlChildSpecVanish) then
        ifnil({self.}XmlChildSpecVanish) ? {self.}SpecVanish.Copy(_obj.XmlChildSpecVanish) : {self.}XmlChildSpecVanish.Copy(_obj.XmlChildSpecVanish);
    if not ifnil(_obj.XmlChildVanish) then
        ifnil({self.}XmlChildVanish) ? {self.}Vanish.Copy(_obj.XmlChildVanish) : {self.}XmlChildVanish.Copy(_obj.XmlChildVanish);
    if not ifnil(_obj.XmlChildShd) then
        {self.}Shd.Copy(_obj.XmlChildShd);
    if not ifnil(_obj.XmlChildSmallCaps) then
        {self.}SmallCaps.Copy(_obj.XmlChildSmallCaps);
    if not ifnil(_obj.XmlChildW) then
        {self.}W.Copy(_obj.XmlChildW);
    tslassigning := tslassigning_backup;
end;

function RPr.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildNoProof) then
        {self.}XmlChildNoProof.ConvertToPoint();
    if not ifnil({self.}XmlChildOutline) then
        {self.}XmlChildOutline.ConvertToPoint();
    if not ifnil({self.}XmlChildPosition) then
        {self.}XmlChildPosition.ConvertToPoint();
    if not ifnil({self.}XmlChildWebHidden) then
        {self.}XmlChildWebHidden.ConvertToPoint();
    if not ifnil({self.}XmlChildRStyle) then
        {self.}XmlChildRStyle.ConvertToPoint();
    if not ifnil({self.}XmlChildIns) then
        {self.}XmlChildIns.ConvertToPoint();
    if not ifnil({self.}XmlChildRFonts) then
        {self.}XmlChildRFonts.ConvertToPoint();
    if not ifnil({self.}XmlChildKern) then
        {self.}XmlChildKern.ConvertToPoint();
    if not ifnil({self.}XmlChildBdr) then
        {self.}XmlChildBdr.ConvertToPoint();
    if not ifnil({self.}XmlChildCaps) then
        {self.}XmlChildCaps.ConvertToPoint();
    if not ifnil({self.}XmlChildDel) then
        {self.}XmlChildDel.ConvertToPoint();
    if not ifnil({self.}XmlChildDStrike) then
        {self.}XmlChildDStrike.ConvertToPoint();
    if not ifnil({self.}XmlChildEffect) then
        {self.}XmlChildEffect.ConvertToPoint();
    if not ifnil({self.}XmlChildEm) then
        {self.}XmlChildEm.ConvertToPoint();
    if not ifnil({self.}XmlChildEmboss) then
        {self.}XmlChildEmboss.ConvertToPoint();
    if not ifnil({self.}XmlChildFitText) then
        {self.}XmlChildFitText.ConvertToPoint();
    if not ifnil({self.}XmlChildHighlight) then
        {self.}XmlChildHighlight.ConvertToPoint();
    if not ifnil({self.}XmlChildColor) then
        {self.}XmlChildColor.ConvertToPoint();
    if not ifnil({self.}XmlChildEastAsianLayout) then
        {self.}XmlChildEastAsianLayout.ConvertToPoint();
    if not ifnil({self.}XmlChildSz) then
        {self.}XmlChildSz.ConvertToPoint();
    if not ifnil({self.}XmlChildSzCs) then
        {self.}XmlChildSzCs.ConvertToPoint();
    if not ifnil({self.}XmlChildLang) then
        {self.}XmlChildLang.ConvertToPoint();
    if not ifnil({self.}XmlChildImprint) then
        {self.}XmlChildImprint.ConvertToPoint();
    if not ifnil({self.}XmlChildVertAlign) then
        {self.}XmlChildVertAlign.ConvertToPoint();
    if not ifnil({self.}XmlChildLigatures) then
        {self.}XmlChildLigatures.ConvertToPoint();
    if not ifnil({self.}XmlChildRtl) then
        {self.}XmlChildRtl.ConvertToPoint();
    if not ifnil({self.}XmlChildShd) then
        {self.}XmlChildShd.ConvertToPoint();
    if not ifnil({self.}XmlChildSmallCaps) then
        {self.}XmlChildSmallCaps.ConvertToPoint();
    if not ifnil({self.}XmlChildW) then
        {self.}XmlChildW.ConvertToPoint();
end;

function RPr.ReadXmlChildI();
begin
    if tslassigning and (ifnil({self.}XmlChildI) or {self.}XmlChildI.Removed) then
    begin
        {self.}XmlChildI := new OpenXmlSimpleType(self, {self.}Prefix, "i");
        container_.Set({self.}XmlChildI);
    end
    return {self.}XmlChildI and not {self.}XmlChildI.Removed ? {self.}XmlChildI : fallback_.XmlChildI;
end;

function RPr.WriteXmlChildI(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildI) then
            {self.}RemoveChild({self.}XmlChildI);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildI := _value;
        container_.Set({self.}XmlChildI);
    end
    else begin
        raise "Invalid assignment: I expects nil or OpenXmlSimpleType";
    end
end;

function RPr.ReadXmlChildICs();
begin
    if tslassigning and (ifnil({self.}XmlChildICs) or {self.}XmlChildICs.Removed) then
    begin
        {self.}XmlChildICs := new OpenXmlSimpleType(self, {self.}Prefix, "iCs");
        container_.Set({self.}XmlChildICs);
    end
    return {self.}XmlChildICs and not {self.}XmlChildICs.Removed ? {self.}XmlChildICs : fallback_.XmlChildICs;
end;

function RPr.WriteXmlChildICs(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildICs) then
            {self.}RemoveChild({self.}XmlChildICs);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildICs := _value;
        container_.Set({self.}XmlChildICs);
    end
    else begin
        raise "Invalid assignment: ICs expects nil or OpenXmlSimpleType";
    end
end;

function RPr.ReadXmlChildB();
begin
    if tslassigning and (ifnil({self.}XmlChildB) or {self.}XmlChildB.Removed) then
    begin
        {self.}XmlChildB := new OpenXmlSimpleType(self, {self.}Prefix, "b");
        container_.Set({self.}XmlChildB);
    end
    return {self.}XmlChildB and not {self.}XmlChildB.Removed ? {self.}XmlChildB : fallback_.XmlChildB;
end;

function RPr.WriteXmlChildB(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildB) then
            {self.}RemoveChild({self.}XmlChildB);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildB := _value;
        container_.Set({self.}XmlChildB);
    end
    else begin
        raise "Invalid assignment: B expects nil or OpenXmlSimpleType";
    end
end;

function RPr.ReadXmlChildBCs();
begin
    if tslassigning and (ifnil({self.}XmlChildBCs) or {self.}XmlChildBCs.Removed) then
    begin
        {self.}XmlChildBCs := new OpenXmlSimpleType(self, {self.}Prefix, "bCs");
        container_.Set({self.}XmlChildBCs);
    end
    return {self.}XmlChildBCs and not {self.}XmlChildBCs.Removed ? {self.}XmlChildBCs : fallback_.XmlChildBCs;
end;

function RPr.WriteXmlChildBCs(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildBCs) then
            {self.}RemoveChild({self.}XmlChildBCs);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildBCs := _value;
        container_.Set({self.}XmlChildBCs);
    end
    else begin
        raise "Invalid assignment: BCs expects nil or OpenXmlSimpleType";
    end
end;

function RPr.ReadXmlChildStrike();
begin
    if tslassigning and (ifnil({self.}XmlChildStrike) or {self.}XmlChildStrike.Removed) then
    begin
        {self.}XmlChildStrike := new OpenXmlSimpleType(self, {self.}Prefix, "strike");
        container_.Set({self.}XmlChildStrike);
    end
    return {self.}XmlChildStrike and not {self.}XmlChildStrike.Removed ? {self.}XmlChildStrike : fallback_.XmlChildStrike;
end;

function RPr.WriteXmlChildStrike(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildStrike) then
            {self.}RemoveChild({self.}XmlChildStrike);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildStrike := _value;
        container_.Set({self.}XmlChildStrike);
    end
    else begin
        raise "Invalid assignment: Strike expects nil or OpenXmlSimpleType";
    end
end;

function RPr.ReadXmlChildCs();
begin
    if tslassigning and (ifnil({self.}XmlChildCs) or {self.}XmlChildCs.Removed) then
    begin
        {self.}XmlChildCs := new OpenXmlSimpleType(self, {self.}Prefix, "cs");
        container_.Set({self.}XmlChildCs);
    end
    return {self.}XmlChildCs and not {self.}XmlChildCs.Removed ? {self.}XmlChildCs : fallback_.XmlChildCs;
end;

function RPr.WriteXmlChildCs(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildCs) then
            {self.}RemoveChild({self.}XmlChildCs);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildCs := _value;
        container_.Set({self.}XmlChildCs);
    end
    else begin
        raise "Invalid assignment: Cs expects nil or OpenXmlSimpleType";
    end
end;

function RPr.ReadXmlChildU();
begin
    if tslassigning and (ifnil({self.}XmlChildU) or {self.}XmlChildU.Removed) then
    begin
        {self.}XmlChildU := new OpenXmlSimpleType(self, {self.}Prefix, "u");
        container_.Set({self.}XmlChildU);
    end
    return {self.}XmlChildU and not {self.}XmlChildU.Removed ? {self.}XmlChildU : fallback_.XmlChildU;
end;

function RPr.WriteXmlChildU(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildU) then
            {self.}RemoveChild({self.}XmlChildU);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildU := _value;
        container_.Set({self.}XmlChildU);
    end
    else begin
        raise "Invalid assignment: U expects nil or OpenXmlSimpleType";
    end
end;

function RPr.ReadXmlChildOMath();
begin
    if tslassigning and (ifnil({self.}XmlChildOMath) or {self.}XmlChildOMath.Removed) then
    begin
        {self.}XmlChildOMath := new OpenXmlSimpleType(self, {self.}Prefix, "oMath");
        container_.Set({self.}XmlChildOMath);
    end
    return {self.}XmlChildOMath and not {self.}XmlChildOMath.Removed ? {self.}XmlChildOMath : fallback_.XmlChildOMath;
end;

function RPr.WriteXmlChildOMath(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildOMath) then
            {self.}RemoveChild({self.}XmlChildOMath);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildOMath := _value;
        container_.Set({self.}XmlChildOMath);
    end
    else begin
        raise "Invalid assignment: OMath expects nil or OpenXmlSimpleType";
    end
end;

function RPr.ReadXmlChildShadow();
begin
    if tslassigning and (ifnil({self.}XmlChildShadow) or {self.}XmlChildShadow.Removed) then
    begin
        {self.}XmlChildShadow := new OpenXmlSimpleType(self, {self.}Prefix, "shadow");
        container_.Set({self.}XmlChildShadow);
    end
    return {self.}XmlChildShadow and not {self.}XmlChildShadow.Removed ? {self.}XmlChildShadow : fallback_.XmlChildShadow;
end;

function RPr.WriteXmlChildShadow(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildShadow) then
            {self.}RemoveChild({self.}XmlChildShadow);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildShadow := _value;
        container_.Set({self.}XmlChildShadow);
    end
    else begin
        raise "Invalid assignment: Shadow expects nil or OpenXmlSimpleType";
    end
end;

function RPr.ReadXmlChildSpecVanish();
begin
    if tslassigning and (ifnil({self.}XmlChildSpecVanish) or {self.}XmlChildSpecVanish.Removed) then
    begin
        {self.}XmlChildSpecVanish := new OpenXmlSimpleType(self, {self.}Prefix, "specVanish");
        container_.Set({self.}XmlChildSpecVanish);
    end
    return {self.}XmlChildSpecVanish and not {self.}XmlChildSpecVanish.Removed ? {self.}XmlChildSpecVanish : fallback_.XmlChildSpecVanish;
end;

function RPr.WriteXmlChildSpecVanish(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildSpecVanish) then
            {self.}RemoveChild({self.}XmlChildSpecVanish);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildSpecVanish := _value;
        container_.Set({self.}XmlChildSpecVanish);
    end
    else begin
        raise "Invalid assignment: SpecVanish expects nil or OpenXmlSimpleType";
    end
end;

function RPr.ReadXmlChildVanish();
begin
    if tslassigning and (ifnil({self.}XmlChildVanish) or {self.}XmlChildVanish.Removed) then
    begin
        {self.}XmlChildVanish := new OpenXmlSimpleType(self, {self.}Prefix, "vanish");
        container_.Set({self.}XmlChildVanish);
    end
    return {self.}XmlChildVanish and not {self.}XmlChildVanish.Removed ? {self.}XmlChildVanish : fallback_.XmlChildVanish;
end;

function RPr.WriteXmlChildVanish(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildVanish) then
            {self.}RemoveChild({self.}XmlChildVanish);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildVanish := _value;
        container_.Set({self.}XmlChildVanish);
    end
    else begin
        raise "Invalid assignment: Vanish expects nil or OpenXmlSimpleType";
    end
end;

function RPr.ReadXmlChildNoProof(): PureVal;
begin
    if tslassigning and (ifnil({self.}XmlChildNoProof) or {self.}XmlChildNoProof.Removed) then
    begin
        {self.}XmlChildNoProof := new PureVal(self, {self.}Prefix, "noProof");
        container_.Set({self.}XmlChildNoProof);
    end
    return {self.}XmlChildNoProof and not {self.}XmlChildNoProof.Removed ? {self.}XmlChildNoProof : fallback_.XmlChildNoProof;
end;

function RPr.WriteXmlChildNoProof(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildNoProof) then
            {self.}RemoveChild({self.}XmlChildNoProof);
    end
    else if v is class(PureVal) then
    begin
        {self.}XmlChildNoProof := v;
        container_.Set({self.}XmlChildNoProof);
    end
    else begin
        raise "Invalid assignment: NoProof expects PureVal or nil";
    end
end;

function RPr.ReadXmlChildOutline(): PureVal;
begin
    if tslassigning and (ifnil({self.}XmlChildOutline) or {self.}XmlChildOutline.Removed) then
    begin
        {self.}XmlChildOutline := new PureVal(self, {self.}Prefix, "outline");
        container_.Set({self.}XmlChildOutline);
    end
    return {self.}XmlChildOutline and not {self.}XmlChildOutline.Removed ? {self.}XmlChildOutline : fallback_.XmlChildOutline;
end;

function RPr.WriteXmlChildOutline(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildOutline) then
            {self.}RemoveChild({self.}XmlChildOutline);
    end
    else if v is class(PureVal) then
    begin
        {self.}XmlChildOutline := v;
        container_.Set({self.}XmlChildOutline);
    end
    else begin
        raise "Invalid assignment: Outline expects PureVal or nil";
    end
end;

function RPr.ReadXmlChildPosition(): PureVal;
begin
    if tslassigning and (ifnil({self.}XmlChildPosition) or {self.}XmlChildPosition.Removed) then
    begin
        {self.}XmlChildPosition := new PureVal(self, {self.}Prefix, "position");
        container_.Set({self.}XmlChildPosition);
    end
    return {self.}XmlChildPosition and not {self.}XmlChildPosition.Removed ? {self.}XmlChildPosition : fallback_.XmlChildPosition;
end;

function RPr.WriteXmlChildPosition(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPosition) then
            {self.}RemoveChild({self.}XmlChildPosition);
    end
    else if v is class(PureVal) then
    begin
        {self.}XmlChildPosition := v;
        container_.Set({self.}XmlChildPosition);
    end
    else begin
        raise "Invalid assignment: Position expects PureVal or nil";
    end
end;

function RPr.ReadXmlChildWebHidden(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildWebHidden) or {self.}XmlChildWebHidden.Removed) then
    begin
        {self.}XmlChildWebHidden := new PureWVal(self, {self.}Prefix, "wedHidden");
        container_.Set({self.}XmlChildWebHidden);
    end
    return {self.}XmlChildWebHidden and not {self.}XmlChildWebHidden.Removed ? {self.}XmlChildWebHidden : fallback_.XmlChildWebHidden;
end;

function RPr.WriteXmlChildWebHidden(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildWebHidden) then
            {self.}RemoveChild({self.}XmlChildWebHidden);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildWebHidden := v;
        container_.Set({self.}XmlChildWebHidden);
    end
    else begin
        raise "Invalid assignment: WebHidden expects PureWVal or nil";
    end
end;

function RPr.ReadXmlChildRStyle(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildRStyle) or {self.}XmlChildRStyle.Removed) then
    begin
        {self.}XmlChildRStyle := new PureWVal(self, {self.}Prefix, "rStyle");
        container_.Set({self.}XmlChildRStyle);
    end
    return {self.}XmlChildRStyle and not {self.}XmlChildRStyle.Removed ? {self.}XmlChildRStyle : fallback_.XmlChildRStyle;
end;

function RPr.WriteXmlChildRStyle(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRStyle) then
            {self.}RemoveChild({self.}XmlChildRStyle);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildRStyle := v;
        container_.Set({self.}XmlChildRStyle);
    end
    else begin
        raise "Invalid assignment: RStyle expects PureWVal or nil";
    end
end;

function RPr.ReadXmlChildIns(): Ins;
begin
    if tslassigning and (ifnil({self.}XmlChildIns) or {self.}XmlChildIns.Removed) then
    begin
        {self.}XmlChildIns := new Ins(self, {self.}Prefix, "ins");
        container_.Set({self.}XmlChildIns);
    end
    return {self.}XmlChildIns and not {self.}XmlChildIns.Removed ? {self.}XmlChildIns : fallback_.XmlChildIns;
end;

function RPr.WriteXmlChildIns(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildIns) then
            {self.}RemoveChild({self.}XmlChildIns);
    end
    else if v is class(Ins) then
    begin
        {self.}XmlChildIns := v;
        container_.Set({self.}XmlChildIns);
    end
    else begin
        raise "Invalid assignment: Ins expects Ins or nil";
    end
end;

function RPr.ReadXmlChildRFonts(): RFonts;
begin
    if tslassigning and (ifnil({self.}XmlChildRFonts) or {self.}XmlChildRFonts.Removed) then
    begin
        {self.}XmlChildRFonts := new RFonts(self, {self.}Prefix, "rFonts");
        container_.Set({self.}XmlChildRFonts);
    end
    return {self.}XmlChildRFonts and not {self.}XmlChildRFonts.Removed ? {self.}XmlChildRFonts : fallback_.XmlChildRFonts;
end;

function RPr.WriteXmlChildRFonts(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRFonts) then
            {self.}RemoveChild({self.}XmlChildRFonts);
    end
    else if v is class(RFonts) then
    begin
        {self.}XmlChildRFonts := v;
        container_.Set({self.}XmlChildRFonts);
    end
    else begin
        raise "Invalid assignment: RFonts expects RFonts or nil";
    end
end;

function RPr.ReadXmlChildKern(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildKern) or {self.}XmlChildKern.Removed) then
    begin
        {self.}XmlChildKern := new PureWVal(self, {self.}Prefix, "kern");
        container_.Set({self.}XmlChildKern);
    end
    return {self.}XmlChildKern and not {self.}XmlChildKern.Removed ? {self.}XmlChildKern : fallback_.XmlChildKern;
end;

function RPr.WriteXmlChildKern(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildKern) then
            {self.}RemoveChild({self.}XmlChildKern);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildKern := v;
        container_.Set({self.}XmlChildKern);
    end
    else begin
        raise "Invalid assignment: Kern expects PureWVal or nil";
    end
end;

function RPr.ReadXmlChildBdr(): Bdr;
begin
    if tslassigning and (ifnil({self.}XmlChildBdr) or {self.}XmlChildBdr.Removed) then
    begin
        {self.}XmlChildBdr := new Bdr(self, {self.}Prefix, "bdr");
        container_.Set({self.}XmlChildBdr);
    end
    return {self.}XmlChildBdr and not {self.}XmlChildBdr.Removed ? {self.}XmlChildBdr : fallback_.XmlChildBdr;
end;

function RPr.WriteXmlChildBdr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildBdr) then
            {self.}RemoveChild({self.}XmlChildBdr);
    end
    else if v is class(Bdr) then
    begin
        {self.}XmlChildBdr := v;
        container_.Set({self.}XmlChildBdr);
    end
    else begin
        raise "Invalid assignment: Bdr expects Bdr or nil";
    end
end;

function RPr.ReadXmlChildCaps(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildCaps) or {self.}XmlChildCaps.Removed) then
    begin
        {self.}XmlChildCaps := new PureWVal(self, {self.}Prefix, "caps");
        container_.Set({self.}XmlChildCaps);
    end
    return {self.}XmlChildCaps and not {self.}XmlChildCaps.Removed ? {self.}XmlChildCaps : fallback_.XmlChildCaps;
end;

function RPr.WriteXmlChildCaps(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildCaps) then
            {self.}RemoveChild({self.}XmlChildCaps);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildCaps := v;
        container_.Set({self.}XmlChildCaps);
    end
    else begin
        raise "Invalid assignment: Caps expects PureWVal or nil";
    end
end;

function RPr.ReadXmlChildDel(): Del;
begin
    if tslassigning and (ifnil({self.}XmlChildDel) or {self.}XmlChildDel.Removed) then
    begin
        {self.}XmlChildDel := new Del(self, {self.}Prefix, "del");
        container_.Set({self.}XmlChildDel);
    end
    return {self.}XmlChildDel and not {self.}XmlChildDel.Removed ? {self.}XmlChildDel : fallback_.XmlChildDel;
end;

function RPr.WriteXmlChildDel(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildDel) then
            {self.}RemoveChild({self.}XmlChildDel);
    end
    else if v is class(Del) then
    begin
        {self.}XmlChildDel := v;
        container_.Set({self.}XmlChildDel);
    end
    else begin
        raise "Invalid assignment: Del expects Del or nil";
    end
end;

function RPr.ReadXmlChildDStrike(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildDStrike) or {self.}XmlChildDStrike.Removed) then
    begin
        {self.}XmlChildDStrike := new PureWVal(self, {self.}Prefix, "dstrike");
        container_.Set({self.}XmlChildDStrike);
    end
    return {self.}XmlChildDStrike and not {self.}XmlChildDStrike.Removed ? {self.}XmlChildDStrike : fallback_.XmlChildDStrike;
end;

function RPr.WriteXmlChildDStrike(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildDStrike) then
            {self.}RemoveChild({self.}XmlChildDStrike);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildDStrike := v;
        container_.Set({self.}XmlChildDStrike);
    end
    else begin
        raise "Invalid assignment: DStrike expects PureWVal or nil";
    end
end;

function RPr.ReadXmlChildEffect(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildEffect) or {self.}XmlChildEffect.Removed) then
    begin
        {self.}XmlChildEffect := new PureWVal(self, {self.}Prefix, "effect");
        container_.Set({self.}XmlChildEffect);
    end
    return {self.}XmlChildEffect and not {self.}XmlChildEffect.Removed ? {self.}XmlChildEffect : fallback_.XmlChildEffect;
end;

function RPr.WriteXmlChildEffect(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildEffect) then
            {self.}RemoveChild({self.}XmlChildEffect);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildEffect := v;
        container_.Set({self.}XmlChildEffect);
    end
    else begin
        raise "Invalid assignment: Effect expects PureWVal or nil";
    end
end;

function RPr.ReadXmlChildEm(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildEm) or {self.}XmlChildEm.Removed) then
    begin
        {self.}XmlChildEm := new PureWVal(self, {self.}Prefix, "em");
        container_.Set({self.}XmlChildEm);
    end
    return {self.}XmlChildEm and not {self.}XmlChildEm.Removed ? {self.}XmlChildEm : fallback_.XmlChildEm;
end;

function RPr.WriteXmlChildEm(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildEm) then
            {self.}RemoveChild({self.}XmlChildEm);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildEm := v;
        container_.Set({self.}XmlChildEm);
    end
    else begin
        raise "Invalid assignment: Em expects PureWVal or nil";
    end
end;

function RPr.ReadXmlChildEmboss(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildEmboss) or {self.}XmlChildEmboss.Removed) then
    begin
        {self.}XmlChildEmboss := new PureWVal(self, {self.}Prefix, "emboss");
        container_.Set({self.}XmlChildEmboss);
    end
    return {self.}XmlChildEmboss and not {self.}XmlChildEmboss.Removed ? {self.}XmlChildEmboss : fallback_.XmlChildEmboss;
end;

function RPr.WriteXmlChildEmboss(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildEmboss) then
            {self.}RemoveChild({self.}XmlChildEmboss);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildEmboss := v;
        container_.Set({self.}XmlChildEmboss);
    end
    else begin
        raise "Invalid assignment: Emboss expects PureWVal or nil";
    end
end;

function RPr.ReadXmlChildFitText(): FitText;
begin
    if tslassigning and (ifnil({self.}XmlChildFitText) or {self.}XmlChildFitText.Removed) then
    begin
        {self.}XmlChildFitText := new FitText(self, {self.}Prefix, "fitText");
        container_.Set({self.}XmlChildFitText);
    end
    return {self.}XmlChildFitText and not {self.}XmlChildFitText.Removed ? {self.}XmlChildFitText : fallback_.XmlChildFitText;
end;

function RPr.WriteXmlChildFitText(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildFitText) then
            {self.}RemoveChild({self.}XmlChildFitText);
    end
    else if v is class(FitText) then
    begin
        {self.}XmlChildFitText := v;
        container_.Set({self.}XmlChildFitText);
    end
    else begin
        raise "Invalid assignment: FitText expects FitText or nil";
    end
end;

function RPr.ReadXmlChildHighlight(): Highlight;
begin
    if tslassigning and (ifnil({self.}XmlChildHighlight) or {self.}XmlChildHighlight.Removed) then
    begin
        {self.}XmlChildHighlight := new Highlight(self, {self.}Prefix, "highlight");
        container_.Set({self.}XmlChildHighlight);
    end
    return {self.}XmlChildHighlight and not {self.}XmlChildHighlight.Removed ? {self.}XmlChildHighlight : fallback_.XmlChildHighlight;
end;

function RPr.WriteXmlChildHighlight(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildHighlight) then
            {self.}RemoveChild({self.}XmlChildHighlight);
    end
    else if v is class(Highlight) then
    begin
        {self.}XmlChildHighlight := v;
        container_.Set({self.}XmlChildHighlight);
    end
    else begin
        raise "Invalid assignment: Highlight expects Highlight or nil";
    end
end;

function RPr.ReadXmlChildColor(): Color;
begin
    if tslassigning and (ifnil({self.}XmlChildColor) or {self.}XmlChildColor.Removed) then
    begin
        {self.}XmlChildColor := new Color(self, {self.}Prefix, "color");
        container_.Set({self.}XmlChildColor);
    end
    return {self.}XmlChildColor and not {self.}XmlChildColor.Removed ? {self.}XmlChildColor : fallback_.XmlChildColor;
end;

function RPr.WriteXmlChildColor(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildColor) then
            {self.}RemoveChild({self.}XmlChildColor);
    end
    else if v is class(Color) then
    begin
        {self.}XmlChildColor := v;
        container_.Set({self.}XmlChildColor);
    end
    else begin
        raise "Invalid assignment: Color expects Color or nil";
    end
end;

function RPr.ReadXmlChildEastAsianLayout(): EastAsianLayout;
begin
    if tslassigning and (ifnil({self.}XmlChildEastAsianLayout) or {self.}XmlChildEastAsianLayout.Removed) then
    begin
        {self.}XmlChildEastAsianLayout := new EastAsianLayout(self, {self.}Prefix, "eastAsianLayout");
        container_.Set({self.}XmlChildEastAsianLayout);
    end
    return {self.}XmlChildEastAsianLayout and not {self.}XmlChildEastAsianLayout.Removed ? {self.}XmlChildEastAsianLayout : fallback_.XmlChildEastAsianLayout;
end;

function RPr.WriteXmlChildEastAsianLayout(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildEastAsianLayout) then
            {self.}RemoveChild({self.}XmlChildEastAsianLayout);
    end
    else if v is class(EastAsianLayout) then
    begin
        {self.}XmlChildEastAsianLayout := v;
        container_.Set({self.}XmlChildEastAsianLayout);
    end
    else begin
        raise "Invalid assignment: EastAsianLayout expects EastAsianLayout or nil";
    end
end;

function RPr.ReadXmlChildSz(): Sz;
begin
    if tslassigning and (ifnil({self.}XmlChildSz) or {self.}XmlChildSz.Removed) then
    begin
        {self.}XmlChildSz := new Sz(self, {self.}Prefix, "sz");
        container_.Set({self.}XmlChildSz);
    end
    return {self.}XmlChildSz and not {self.}XmlChildSz.Removed ? {self.}XmlChildSz : fallback_.XmlChildSz;
end;

function RPr.WriteXmlChildSz(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildSz) then
            {self.}RemoveChild({self.}XmlChildSz);
    end
    else if v is class(Sz) then
    begin
        {self.}XmlChildSz := v;
        container_.Set({self.}XmlChildSz);
    end
    else begin
        raise "Invalid assignment: Sz expects Sz or nil";
    end
end;

function RPr.ReadXmlChildSzCs(): SzCs;
begin
    if tslassigning and (ifnil({self.}XmlChildSzCs) or {self.}XmlChildSzCs.Removed) then
    begin
        {self.}XmlChildSzCs := new SzCs(self, {self.}Prefix, "szCs");
        container_.Set({self.}XmlChildSzCs);
    end
    return {self.}XmlChildSzCs and not {self.}XmlChildSzCs.Removed ? {self.}XmlChildSzCs : fallback_.XmlChildSzCs;
end;

function RPr.WriteXmlChildSzCs(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildSzCs) then
            {self.}RemoveChild({self.}XmlChildSzCs);
    end
    else if v is class(SzCs) then
    begin
        {self.}XmlChildSzCs := v;
        container_.Set({self.}XmlChildSzCs);
    end
    else begin
        raise "Invalid assignment: SzCs expects SzCs or nil";
    end
end;

function RPr.ReadXmlChildLang(): Lang;
begin
    if tslassigning and (ifnil({self.}XmlChildLang) or {self.}XmlChildLang.Removed) then
    begin
        {self.}XmlChildLang := new Lang(self, {self.}Prefix, "lang");
        container_.Set({self.}XmlChildLang);
    end
    return {self.}XmlChildLang and not {self.}XmlChildLang.Removed ? {self.}XmlChildLang : fallback_.XmlChildLang;
end;

function RPr.WriteXmlChildLang(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildLang) then
            {self.}RemoveChild({self.}XmlChildLang);
    end
    else if v is class(Lang) then
    begin
        {self.}XmlChildLang := v;
        container_.Set({self.}XmlChildLang);
    end
    else begin
        raise "Invalid assignment: Lang expects Lang or nil";
    end
end;

function RPr.ReadXmlChildImprint(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildImprint) or {self.}XmlChildImprint.Removed) then
    begin
        {self.}XmlChildImprint := new PureWVal(self, {self.}Prefix, "imprint");
        container_.Set({self.}XmlChildImprint);
    end
    return {self.}XmlChildImprint and not {self.}XmlChildImprint.Removed ? {self.}XmlChildImprint : fallback_.XmlChildImprint;
end;

function RPr.WriteXmlChildImprint(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildImprint) then
            {self.}RemoveChild({self.}XmlChildImprint);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildImprint := v;
        container_.Set({self.}XmlChildImprint);
    end
    else begin
        raise "Invalid assignment: Imprint expects PureWVal or nil";
    end
end;

function RPr.ReadXmlChildVertAlign(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildVertAlign) or {self.}XmlChildVertAlign.Removed) then
    begin
        {self.}XmlChildVertAlign := new PureWVal(self, {self.}Prefix, "vertAlign");
        container_.Set({self.}XmlChildVertAlign);
    end
    return {self.}XmlChildVertAlign and not {self.}XmlChildVertAlign.Removed ? {self.}XmlChildVertAlign : fallback_.XmlChildVertAlign;
end;

function RPr.WriteXmlChildVertAlign(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildVertAlign) then
            {self.}RemoveChild({self.}XmlChildVertAlign);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildVertAlign := v;
        container_.Set({self.}XmlChildVertAlign);
    end
    else begin
        raise "Invalid assignment: VertAlign expects PureWVal or nil";
    end
end;

function RPr.ReadXmlChildLigatures(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildLigatures) or {self.}XmlChildLigatures.Removed) then
    begin
        {self.}XmlChildLigatures := new PureWVal(self, "w14", "ligatures");
        container_.Set({self.}XmlChildLigatures);
    end
    return {self.}XmlChildLigatures and not {self.}XmlChildLigatures.Removed ? {self.}XmlChildLigatures : fallback_.XmlChildLigatures;
end;

function RPr.WriteXmlChildLigatures(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildLigatures) then
            {self.}RemoveChild({self.}XmlChildLigatures);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildLigatures := v;
        container_.Set({self.}XmlChildLigatures);
    end
    else begin
        raise "Invalid assignment: Ligatures expects PureWVal or nil";
    end
end;

function RPr.ReadXmlChildRtl(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildRtl) or {self.}XmlChildRtl.Removed) then
    begin
        {self.}XmlChildRtl := new PureWVal(self, {self.}Prefix, "rtl");
        container_.Set({self.}XmlChildRtl);
    end
    return {self.}XmlChildRtl and not {self.}XmlChildRtl.Removed ? {self.}XmlChildRtl : fallback_.XmlChildRtl;
end;

function RPr.WriteXmlChildRtl(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRtl) then
            {self.}RemoveChild({self.}XmlChildRtl);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildRtl := v;
        container_.Set({self.}XmlChildRtl);
    end
    else begin
        raise "Invalid assignment: Rtl expects PureWVal or nil";
    end
end;

function RPr.ReadXmlChildShd(): Shd;
begin
    if tslassigning and (ifnil({self.}XmlChildShd) or {self.}XmlChildShd.Removed) then
    begin
        {self.}XmlChildShd := new Shd(self, {self.}Prefix, "shd");
        container_.Set({self.}XmlChildShd);
    end
    return {self.}XmlChildShd and not {self.}XmlChildShd.Removed ? {self.}XmlChildShd : fallback_.XmlChildShd;
end;

function RPr.WriteXmlChildShd(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildShd) then
            {self.}RemoveChild({self.}XmlChildShd);
    end
    else if v is class(Shd) then
    begin
        {self.}XmlChildShd := v;
        container_.Set({self.}XmlChildShd);
    end
    else begin
        raise "Invalid assignment: Shd expects Shd or nil";
    end
end;

function RPr.ReadXmlChildSmallCaps(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildSmallCaps) or {self.}XmlChildSmallCaps.Removed) then
    begin
        {self.}XmlChildSmallCaps := new PureWVal(self, {self.}Prefix, "smallCaps");
        container_.Set({self.}XmlChildSmallCaps);
    end
    return {self.}XmlChildSmallCaps and not {self.}XmlChildSmallCaps.Removed ? {self.}XmlChildSmallCaps : fallback_.XmlChildSmallCaps;
end;

function RPr.WriteXmlChildSmallCaps(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildSmallCaps) then
            {self.}RemoveChild({self.}XmlChildSmallCaps);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildSmallCaps := v;
        container_.Set({self.}XmlChildSmallCaps);
    end
    else begin
        raise "Invalid assignment: SmallCaps expects PureWVal or nil";
    end
end;

function RPr.ReadXmlChildW(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildW) or {self.}XmlChildW.Removed) then
    begin
        {self.}XmlChildW := new PureWVal(self, {self.}Prefix, "w");
        container_.Set({self.}XmlChildW);
    end
    return {self.}XmlChildW and not {self.}XmlChildW.Removed ? {self.}XmlChildW : fallback_.XmlChildW;
end;

function RPr.WriteXmlChildW(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildW) then
            {self.}RemoveChild({self.}XmlChildW);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildW := v;
        container_.Set({self.}XmlChildW);
    end
    else begin
        raise "Invalid assignment: W expects PureWVal or nil";
    end
end;

function Shd.Create();overload;
begin
    {self.}Create(nil, "w", "shd");
end;

function Shd.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Shd.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Shd.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "val": makeweakref(thisFunction(WriteXmlAttrVal)),
        pre + "color": makeweakref(thisFunction(WriteXmlAttrColor)),
        pre + "fill": makeweakref(thisFunction(WriteXmlAttrFill)),
        pre + "themeColor": makeweakref(thisFunction(WriteXmlAttrThemeColor)),
        pre + "themeFill": makeweakref(thisFunction(WriteXmlAttrThemeFill)),
        pre + "themeFillTint": makeweakref(thisFunction(WriteXmlAttrThemeFillTint)),
        pre + "themeFillShade": makeweakref(thisFunction(WriteXmlAttrThemeFillShade)),
        pre + "themeShade": makeweakref(thisFunction(WriteXmlAttrThemeShade)),
        pre + "themeTint": makeweakref(thisFunction(WriteXmlAttrThemeTint)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Shd.Copy(_obj: Shd);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    if not ifnil(_obj.Color) then
        {self.}Color := _obj.Color;
    if not ifnil(_obj.Fill) then
        {self.}Fill := _obj.Fill;
    if not ifnil(_obj.ThemeColor) then
        {self.}ThemeColor := _obj.ThemeColor;
    if not ifnil(_obj.ThemeFill) then
        {self.}ThemeFill := _obj.ThemeFill;
    if not ifnil(_obj.ThemeFillTint) then
        {self.}ThemeFillTint := _obj.ThemeFillTint;
    if not ifnil(_obj.ThemeFillShade) then
        {self.}ThemeFillShade := _obj.ThemeFillShade;
    if not ifnil(_obj.ThemeShade) then
        {self.}ThemeShade := _obj.ThemeShade;
    if not ifnil(_obj.ThemeTint) then
        {self.}ThemeTint := _obj.ThemeTint;
    tslassigning := tslassigning_backup;
end;

function Shd.ConvertToPoint();override;
begin

end;

function Shd.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function Shd.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute({self.}Prefix, "val", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "val" : "val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function Shd.ReadXmlAttrColor();
begin
    return ifnil({self.}XmlAttrColor.Value) ? fallback_.XmlAttrColor.Value : {self.}XmlAttrColor.Value;
end;

function Shd.WriteXmlAttrColor(_value: any);
begin
    if ifnil({self.}XmlAttrColor) then
    begin
        {self.}XmlAttrColor := new OpenXmlAttribute({self.}Prefix, "color", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "color" : "color"] := {self.}XmlAttrColor;
    end
    {self.}XmlAttrColor.Value := _value;
end;

function Shd.ReadXmlAttrFill();
begin
    return ifnil({self.}XmlAttrFill.Value) ? fallback_.XmlAttrFill.Value : {self.}XmlAttrFill.Value;
end;

function Shd.WriteXmlAttrFill(_value: any);
begin
    if ifnil({self.}XmlAttrFill) then
    begin
        {self.}XmlAttrFill := new OpenXmlAttribute({self.}Prefix, "fill", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "fill" : "fill"] := {self.}XmlAttrFill;
    end
    {self.}XmlAttrFill.Value := _value;
end;

function Shd.ReadXmlAttrThemeColor();
begin
    return ifnil({self.}XmlAttrThemeColor.Value) ? fallback_.XmlAttrThemeColor.Value : {self.}XmlAttrThemeColor.Value;
end;

function Shd.WriteXmlAttrThemeColor(_value: any);
begin
    if ifnil({self.}XmlAttrThemeColor) then
    begin
        {self.}XmlAttrThemeColor := new OpenXmlAttribute({self.}Prefix, "themeColor", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeColor" : "themeColor"] := {self.}XmlAttrThemeColor;
    end
    {self.}XmlAttrThemeColor.Value := _value;
end;

function Shd.ReadXmlAttrThemeFill();
begin
    return ifnil({self.}XmlAttrThemeFill.Value) ? fallback_.XmlAttrThemeFill.Value : {self.}XmlAttrThemeFill.Value;
end;

function Shd.WriteXmlAttrThemeFill(_value: any);
begin
    if ifnil({self.}XmlAttrThemeFill) then
    begin
        {self.}XmlAttrThemeFill := new OpenXmlAttribute({self.}Prefix, "themeFill", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeFill" : "themeFill"] := {self.}XmlAttrThemeFill;
    end
    {self.}XmlAttrThemeFill.Value := _value;
end;

function Shd.ReadXmlAttrThemeFillTint();
begin
    return ifnil({self.}XmlAttrThemeFillTint.Value) ? fallback_.XmlAttrThemeFillTint.Value : {self.}XmlAttrThemeFillTint.Value;
end;

function Shd.WriteXmlAttrThemeFillTint(_value: any);
begin
    if ifnil({self.}XmlAttrThemeFillTint) then
    begin
        {self.}XmlAttrThemeFillTint := new OpenXmlAttribute({self.}Prefix, "themeFillTint", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeFillTint" : "themeFillTint"] := {self.}XmlAttrThemeFillTint;
    end
    {self.}XmlAttrThemeFillTint.Value := _value;
end;

function Shd.ReadXmlAttrThemeFillShade();
begin
    return ifnil({self.}XmlAttrThemeFillShade.Value) ? fallback_.XmlAttrThemeFillShade.Value : {self.}XmlAttrThemeFillShade.Value;
end;

function Shd.WriteXmlAttrThemeFillShade(_value: any);
begin
    if ifnil({self.}XmlAttrThemeFillShade) then
    begin
        {self.}XmlAttrThemeFillShade := new OpenXmlAttribute({self.}Prefix, "themeFillShade", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeFillShade" : "themeFillShade"] := {self.}XmlAttrThemeFillShade;
    end
    {self.}XmlAttrThemeFillShade.Value := _value;
end;

function Shd.ReadXmlAttrThemeShade();
begin
    return ifnil({self.}XmlAttrThemeShade.Value) ? fallback_.XmlAttrThemeShade.Value : {self.}XmlAttrThemeShade.Value;
end;

function Shd.WriteXmlAttrThemeShade(_value: any);
begin
    if ifnil({self.}XmlAttrThemeShade) then
    begin
        {self.}XmlAttrThemeShade := new OpenXmlAttribute({self.}Prefix, "themeShade", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeShade" : "themeShade"] := {self.}XmlAttrThemeShade;
    end
    {self.}XmlAttrThemeShade.Value := _value;
end;

function Shd.ReadXmlAttrThemeTint();
begin
    return ifnil({self.}XmlAttrThemeTint.Value) ? fallback_.XmlAttrThemeTint.Value : {self.}XmlAttrThemeTint.Value;
end;

function Shd.WriteXmlAttrThemeTint(_value: any);
begin
    if ifnil({self.}XmlAttrThemeTint) then
    begin
        {self.}XmlAttrThemeTint := new OpenXmlAttribute({self.}Prefix, "themeTint", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeTint" : "themeTint"] := {self.}XmlAttrThemeTint;
    end
    {self.}XmlAttrThemeTint.Value := _value;
end;

function Highlight.Create();overload;
begin
    {self.}Create(nil, "w", "highlight");
end;

function Highlight.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Highlight.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Highlight.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "val": makeweakref(thisFunction(WriteXmlAttrVal)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Highlight.Copy(_obj: Highlight);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    tslassigning := tslassigning_backup;
end;

function Highlight.ConvertToPoint();override;
begin

end;

function Highlight.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function Highlight.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute({self.}Prefix, "val", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "val" : "val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function FitText.Create();overload;
begin
    {self.}Create(nil, "w", "fitText");
end;

function FitText.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function FitText.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function FitText.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "id": makeweakref(thisFunction(WriteXmlAttrId)),
        pre + "val": makeweakref(thisFunction(WriteXmlAttrVal)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function FitText.Copy(_obj: FitText);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Id) then
        {self.}Id := _obj.Id;
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    tslassigning := tslassigning_backup;
end;

function FitText.ConvertToPoint();override;
begin

end;

function FitText.ReadXmlAttrId();
begin
    return ifnil({self.}XmlAttrId.Value) ? fallback_.XmlAttrId.Value : {self.}XmlAttrId.Value;
end;

function FitText.WriteXmlAttrId(_value: any);
begin
    if ifnil({self.}XmlAttrId) then
    begin
        {self.}XmlAttrId := new OpenXmlAttribute({self.}Prefix, "id", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "id" : "id"] := {self.}XmlAttrId;
    end
    {self.}XmlAttrId.Value := _value;
end;

function FitText.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function FitText.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute({self.}Prefix, "val", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "val" : "val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function EastAsianLayout.Create();overload;
begin
    {self.}Create(nil, "w", "eastAsianLayout");
end;

function EastAsianLayout.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function EastAsianLayout.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function EastAsianLayout.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "combine": makeweakref(thisFunction(WriteXmlAttrCombine)),
        pre + "combineBrackets": makeweakref(thisFunction(WriteXmlAttrCombineBrackets)),
        pre + "id": makeweakref(thisFunction(WriteXmlAttrId)),
        pre + "vert": makeweakref(thisFunction(WriteXmlAttrVert)),
        pre + "vertCompress": makeweakref(thisFunction(WriteXmlAttrVertCompress)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function EastAsianLayout.Copy(_obj: EastAsianLayout);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Combine) then
        {self.}Combine := _obj.Combine;
    if not ifnil(_obj.CombineBrackets) then
        {self.}CombineBrackets := _obj.CombineBrackets;
    if not ifnil(_obj.Id) then
        {self.}Id := _obj.Id;
    if not ifnil(_obj.Vert) then
        {self.}Vert := _obj.Vert;
    if not ifnil(_obj.VertCompress) then
        {self.}VertCompress := _obj.VertCompress;
    tslassigning := tslassigning_backup;
end;

function EastAsianLayout.ConvertToPoint();override;
begin

end;

function EastAsianLayout.ReadXmlAttrCombine();
begin
    return ifnil({self.}XmlAttrCombine.Value) ? fallback_.XmlAttrCombine.Value : {self.}XmlAttrCombine.Value;
end;

function EastAsianLayout.WriteXmlAttrCombine(_value: any);
begin
    if ifnil({self.}XmlAttrCombine) then
    begin
        {self.}XmlAttrCombine := new OpenXmlAttribute({self.}Prefix, "combine", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "combine" : "combine"] := {self.}XmlAttrCombine;
    end
    {self.}XmlAttrCombine.Value := _value;
end;

function EastAsianLayout.ReadXmlAttrCombineBrackets();
begin
    return ifnil({self.}XmlAttrCombineBrackets.Value) ? fallback_.XmlAttrCombineBrackets.Value : {self.}XmlAttrCombineBrackets.Value;
end;

function EastAsianLayout.WriteXmlAttrCombineBrackets(_value: any);
begin
    if ifnil({self.}XmlAttrCombineBrackets) then
    begin
        {self.}XmlAttrCombineBrackets := new OpenXmlAttribute({self.}Prefix, "combineBrackets", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "combineBrackets" : "combineBrackets"] := {self.}XmlAttrCombineBrackets;
    end
    {self.}XmlAttrCombineBrackets.Value := _value;
end;

function EastAsianLayout.ReadXmlAttrId();
begin
    return ifnil({self.}XmlAttrId.Value) ? fallback_.XmlAttrId.Value : {self.}XmlAttrId.Value;
end;

function EastAsianLayout.WriteXmlAttrId(_value: any);
begin
    if ifnil({self.}XmlAttrId) then
    begin
        {self.}XmlAttrId := new OpenXmlAttribute({self.}Prefix, "id", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "id" : "id"] := {self.}XmlAttrId;
    end
    {self.}XmlAttrId.Value := _value;
end;

function EastAsianLayout.ReadXmlAttrVert();
begin
    return ifnil({self.}XmlAttrVert.Value) ? fallback_.XmlAttrVert.Value : {self.}XmlAttrVert.Value;
end;

function EastAsianLayout.WriteXmlAttrVert(_value: any);
begin
    if ifnil({self.}XmlAttrVert) then
    begin
        {self.}XmlAttrVert := new OpenXmlAttribute({self.}Prefix, "vert", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "vert" : "vert"] := {self.}XmlAttrVert;
    end
    {self.}XmlAttrVert.Value := _value;
end;

function EastAsianLayout.ReadXmlAttrVertCompress();
begin
    return ifnil({self.}XmlAttrVertCompress.Value) ? fallback_.XmlAttrVertCompress.Value : {self.}XmlAttrVertCompress.Value;
end;

function EastAsianLayout.WriteXmlAttrVertCompress(_value: any);
begin
    if ifnil({self.}XmlAttrVertCompress) then
    begin
        {self.}XmlAttrVertCompress := new OpenXmlAttribute({self.}Prefix, "vertCompress", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "vertCompress" : "vertCompress"] := {self.}XmlAttrVertCompress;
    end
    {self.}XmlAttrVertCompress.Value := _value;
end;

function Del.Create();overload;
begin
    {self.}Create(nil, "w", "del");
end;

function Del.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Del.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Del.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "author": makeweakref(thisFunction(WriteXmlAttrAuthor)),
        pre + "date": makeweakref(thisFunction(WriteXmlAttrDate)),
        pre + "id": makeweakref(thisFunction(WriteXmlAttrId)),
        pre + "color": makeweakref(thisFunction(WriteXmlAttrColor)),
        pre + "themeColor": makeweakref(thisFunction(WriteXmlAttrThemeColor)),
        pre + "themeShade": makeweakref(thisFunction(WriteXmlAttrThemeShade)),
        pre + "themeTint": makeweakref(thisFunction(WriteXmlAttrThemeTint)),
        pre + "frame": makeweakref(thisFunction(WriteXmlAttrFrame)),
        pre + "shadow": makeweakref(thisFunction(WriteXmlAttrShadow)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Del.Copy(_obj: Del);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Author) then
        {self.}Author := _obj.Author;
    if not ifnil(_obj.Date) then
        {self.}Date := _obj.Date;
    if not ifnil(_obj.Id) then
        {self.}Id := _obj.Id;
    if not ifnil(_obj.Color) then
        {self.}Color := _obj.Color;
    if not ifnil(_obj.ThemeColor) then
        {self.}ThemeColor := _obj.ThemeColor;
    if not ifnil(_obj.ThemeShade) then
        {self.}ThemeShade := _obj.ThemeShade;
    if not ifnil(_obj.ThemeTint) then
        {self.}ThemeTint := _obj.ThemeTint;
    if not ifnil(_obj.Frame) then
        {self.}Frame := _obj.Frame;
    if not ifnil(_obj.Shadow) then
        {self.}Shadow := _obj.Shadow;
    tslassigning := tslassigning_backup;
end;

function Del.ConvertToPoint();override;
begin

end;

function Del.ReadXmlAttrAuthor();
begin
    return ifnil({self.}XmlAttrAuthor.Value) ? fallback_.XmlAttrAuthor.Value : {self.}XmlAttrAuthor.Value;
end;

function Del.WriteXmlAttrAuthor(_value: any);
begin
    if ifnil({self.}XmlAttrAuthor) then
    begin
        {self.}XmlAttrAuthor := new OpenXmlAttribute({self.}Prefix, "author", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "author" : "author"] := {self.}XmlAttrAuthor;
    end
    {self.}XmlAttrAuthor.Value := _value;
end;

function Del.ReadXmlAttrDate();
begin
    return ifnil({self.}XmlAttrDate.Value) ? fallback_.XmlAttrDate.Value : {self.}XmlAttrDate.Value;
end;

function Del.WriteXmlAttrDate(_value: any);
begin
    if ifnil({self.}XmlAttrDate) then
    begin
        {self.}XmlAttrDate := new OpenXmlAttribute({self.}Prefix, "date", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "date" : "date"] := {self.}XmlAttrDate;
    end
    {self.}XmlAttrDate.Value := _value;
end;

function Del.ReadXmlAttrId();
begin
    return ifnil({self.}XmlAttrId.Value) ? fallback_.XmlAttrId.Value : {self.}XmlAttrId.Value;
end;

function Del.WriteXmlAttrId(_value: any);
begin
    if ifnil({self.}XmlAttrId) then
    begin
        {self.}XmlAttrId := new OpenXmlAttribute({self.}Prefix, "id", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "id" : "id"] := {self.}XmlAttrId;
    end
    {self.}XmlAttrId.Value := _value;
end;

function Del.ReadXmlAttrColor();
begin
    return ifnil({self.}XmlAttrColor.Value) ? fallback_.XmlAttrColor.Value : {self.}XmlAttrColor.Value;
end;

function Del.WriteXmlAttrColor(_value: any);
begin
    if ifnil({self.}XmlAttrColor) then
    begin
        {self.}XmlAttrColor := new OpenXmlAttribute({self.}Prefix, "color", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "color" : "color"] := {self.}XmlAttrColor;
    end
    {self.}XmlAttrColor.Value := _value;
end;

function Del.ReadXmlAttrThemeColor();
begin
    return ifnil({self.}XmlAttrThemeColor.Value) ? fallback_.XmlAttrThemeColor.Value : {self.}XmlAttrThemeColor.Value;
end;

function Del.WriteXmlAttrThemeColor(_value: any);
begin
    if ifnil({self.}XmlAttrThemeColor) then
    begin
        {self.}XmlAttrThemeColor := new OpenXmlAttribute({self.}Prefix, "themeColor", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeColor" : "themeColor"] := {self.}XmlAttrThemeColor;
    end
    {self.}XmlAttrThemeColor.Value := _value;
end;

function Del.ReadXmlAttrThemeShade();
begin
    return ifnil({self.}XmlAttrThemeShade.Value) ? fallback_.XmlAttrThemeShade.Value : {self.}XmlAttrThemeShade.Value;
end;

function Del.WriteXmlAttrThemeShade(_value: any);
begin
    if ifnil({self.}XmlAttrThemeShade) then
    begin
        {self.}XmlAttrThemeShade := new OpenXmlAttribute({self.}Prefix, "themeShade", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeShade" : "themeShade"] := {self.}XmlAttrThemeShade;
    end
    {self.}XmlAttrThemeShade.Value := _value;
end;

function Del.ReadXmlAttrThemeTint();
begin
    return ifnil({self.}XmlAttrThemeTint.Value) ? fallback_.XmlAttrThemeTint.Value : {self.}XmlAttrThemeTint.Value;
end;

function Del.WriteXmlAttrThemeTint(_value: any);
begin
    if ifnil({self.}XmlAttrThemeTint) then
    begin
        {self.}XmlAttrThemeTint := new OpenXmlAttribute({self.}Prefix, "themeTint", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeTint" : "themeTint"] := {self.}XmlAttrThemeTint;
    end
    {self.}XmlAttrThemeTint.Value := _value;
end;

function Del.ReadXmlAttrFrame();
begin
    return ifnil({self.}XmlAttrFrame.Value) ? fallback_.XmlAttrFrame.Value : {self.}XmlAttrFrame.Value;
end;

function Del.WriteXmlAttrFrame(_value: any);
begin
    if ifnil({self.}XmlAttrFrame) then
    begin
        {self.}XmlAttrFrame := new OpenXmlAttribute({self.}Prefix, "frame", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "frame" : "frame"] := {self.}XmlAttrFrame;
    end
    {self.}XmlAttrFrame.Value := _value;
end;

function Del.ReadXmlAttrShadow();
begin
    return ifnil({self.}XmlAttrShadow.Value) ? fallback_.XmlAttrShadow.Value : {self.}XmlAttrShadow.Value;
end;

function Del.WriteXmlAttrShadow(_value: any);
begin
    if ifnil({self.}XmlAttrShadow) then
    begin
        {self.}XmlAttrShadow := new OpenXmlAttribute({self.}Prefix, "shadow", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "shadow" : "shadow"] := {self.}XmlAttrShadow;
    end
    {self.}XmlAttrShadow.Value := _value;
end;

function Bdr.Create();overload;
begin
    {self.}Create(nil, "w", "bdr");
end;

function Bdr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Bdr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Bdr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "val": makeweakref(thisFunction(WriteXmlAttrVal)),
        pre + "sz": makeweakref(thisFunction(WriteXmlAttrSz)),
        pre + "space": makeweakref(thisFunction(WriteXmlAttrSpace)),
        pre + "color": makeweakref(thisFunction(WriteXmlAttrColor)),
        pre + "themeColor": makeweakref(thisFunction(WriteXmlAttrThemeColor)),
        pre + "themeShade": makeweakref(thisFunction(WriteXmlAttrThemeShade)),
        pre + "themeTint": makeweakref(thisFunction(WriteXmlAttrThemeTint)),
        pre + "frame": makeweakref(thisFunction(WriteXmlAttrFrame)),
        pre + "shadow": makeweakref(thisFunction(WriteXmlAttrShadow)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Bdr.Copy(_obj: Bdr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    if not ifnil(_obj.Sz) then
        {self.}Sz := _obj.Sz;
    if not ifnil(_obj.Space) then
        {self.}Space := _obj.Space;
    if not ifnil(_obj.Color) then
        {self.}Color := _obj.Color;
    if not ifnil(_obj.ThemeColor) then
        {self.}ThemeColor := _obj.ThemeColor;
    if not ifnil(_obj.ThemeShade) then
        {self.}ThemeShade := _obj.ThemeShade;
    if not ifnil(_obj.ThemeTint) then
        {self.}ThemeTint := _obj.ThemeTint;
    if not ifnil(_obj.Frame) then
        {self.}Frame := _obj.Frame;
    if not ifnil(_obj.Shadow) then
        {self.}Shadow := _obj.Shadow;
    tslassigning := tslassigning_backup;
end;

function Bdr.ConvertToPoint();override;
begin

end;

function Bdr.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function Bdr.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute({self.}Prefix, "val", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "val" : "val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function Bdr.ReadXmlAttrSz();
begin
    return ifnil({self.}XmlAttrSz.Value) ? fallback_.XmlAttrSz.Value : {self.}XmlAttrSz.Value;
end;

function Bdr.WriteXmlAttrSz(_value: any);
begin
    if ifnil({self.}XmlAttrSz) then
    begin
        {self.}XmlAttrSz := new OpenXmlAttribute({self.}Prefix, "sz", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "sz" : "sz"] := {self.}XmlAttrSz;
    end
    {self.}XmlAttrSz.Value := _value;
end;

function Bdr.ReadXmlAttrSpace();
begin
    return ifnil({self.}XmlAttrSpace.Value) ? fallback_.XmlAttrSpace.Value : {self.}XmlAttrSpace.Value;
end;

function Bdr.WriteXmlAttrSpace(_value: any);
begin
    if ifnil({self.}XmlAttrSpace) then
    begin
        {self.}XmlAttrSpace := new OpenXmlAttribute({self.}Prefix, "space", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "space" : "space"] := {self.}XmlAttrSpace;
    end
    {self.}XmlAttrSpace.Value := _value;
end;

function Bdr.ReadXmlAttrColor();
begin
    return ifnil({self.}XmlAttrColor.Value) ? fallback_.XmlAttrColor.Value : {self.}XmlAttrColor.Value;
end;

function Bdr.WriteXmlAttrColor(_value: any);
begin
    if ifnil({self.}XmlAttrColor) then
    begin
        {self.}XmlAttrColor := new OpenXmlAttribute({self.}Prefix, "color", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "color" : "color"] := {self.}XmlAttrColor;
    end
    {self.}XmlAttrColor.Value := _value;
end;

function Bdr.ReadXmlAttrThemeColor();
begin
    return ifnil({self.}XmlAttrThemeColor.Value) ? fallback_.XmlAttrThemeColor.Value : {self.}XmlAttrThemeColor.Value;
end;

function Bdr.WriteXmlAttrThemeColor(_value: any);
begin
    if ifnil({self.}XmlAttrThemeColor) then
    begin
        {self.}XmlAttrThemeColor := new OpenXmlAttribute({self.}Prefix, "themeColor", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeColor" : "themeColor"] := {self.}XmlAttrThemeColor;
    end
    {self.}XmlAttrThemeColor.Value := _value;
end;

function Bdr.ReadXmlAttrThemeShade();
begin
    return ifnil({self.}XmlAttrThemeShade.Value) ? fallback_.XmlAttrThemeShade.Value : {self.}XmlAttrThemeShade.Value;
end;

function Bdr.WriteXmlAttrThemeShade(_value: any);
begin
    if ifnil({self.}XmlAttrThemeShade) then
    begin
        {self.}XmlAttrThemeShade := new OpenXmlAttribute({self.}Prefix, "themeShade", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeShade" : "themeShade"] := {self.}XmlAttrThemeShade;
    end
    {self.}XmlAttrThemeShade.Value := _value;
end;

function Bdr.ReadXmlAttrThemeTint();
begin
    return ifnil({self.}XmlAttrThemeTint.Value) ? fallback_.XmlAttrThemeTint.Value : {self.}XmlAttrThemeTint.Value;
end;

function Bdr.WriteXmlAttrThemeTint(_value: any);
begin
    if ifnil({self.}XmlAttrThemeTint) then
    begin
        {self.}XmlAttrThemeTint := new OpenXmlAttribute({self.}Prefix, "themeTint", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeTint" : "themeTint"] := {self.}XmlAttrThemeTint;
    end
    {self.}XmlAttrThemeTint.Value := _value;
end;

function Bdr.ReadXmlAttrFrame();
begin
    return ifnil({self.}XmlAttrFrame.Value) ? fallback_.XmlAttrFrame.Value : {self.}XmlAttrFrame.Value;
end;

function Bdr.WriteXmlAttrFrame(_value: any);
begin
    if ifnil({self.}XmlAttrFrame) then
    begin
        {self.}XmlAttrFrame := new OpenXmlAttribute({self.}Prefix, "frame", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "frame" : "frame"] := {self.}XmlAttrFrame;
    end
    {self.}XmlAttrFrame.Value := _value;
end;

function Bdr.ReadXmlAttrShadow();
begin
    return ifnil({self.}XmlAttrShadow.Value) ? fallback_.XmlAttrShadow.Value : {self.}XmlAttrShadow.Value;
end;

function Bdr.WriteXmlAttrShadow(_value: any);
begin
    if ifnil({self.}XmlAttrShadow) then
    begin
        {self.}XmlAttrShadow := new OpenXmlAttribute({self.}Prefix, "shadow", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "shadow" : "shadow"] := {self.}XmlAttrShadow;
    end
    {self.}XmlAttrShadow.Value := _value;
end;

function RFonts.Create();overload;
begin
    {self.}Create(nil, "w", "rFonts");
end;

function RFonts.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function RFonts.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function RFonts.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "hint": makeweakref(thisFunction(WriteXmlAttrHint)),
        pre + "ascii": makeweakref(thisFunction(WriteXmlAttrAscii)),
        pre + "asciiTheme": makeweakref(thisFunction(WriteXmlAttrAsciiTheme)),
        pre + "eastAsia": makeweakref(thisFunction(WriteXmlAttrEastAsia)),
        pre + "eastAsiaTheme": makeweakref(thisFunction(WriteXmlAttrEastAsiaTheme)),
        pre + "hAnsi": makeweakref(thisFunction(WriteXmlAttrHAnsi)),
        pre + "hAnsiTheme": makeweakref(thisFunction(WriteXmlAttrHAnsiTheme)),
        pre + "cs": makeweakref(thisFunction(WriteXmlAttrCs)),
        pre + "cstheme": makeweakref(thisFunction(WriteXmlAttrCsTheme)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function RFonts.Copy(_obj: RFonts);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Hint) then
        {self.}Hint := _obj.Hint;
    if not ifnil(_obj.Ascii) then
        {self.}Ascii := _obj.Ascii;
    if not ifnil(_obj.AsciiTheme) then
        {self.}AsciiTheme := _obj.AsciiTheme;
    if not ifnil(_obj.EastAsia) then
        {self.}EastAsia := _obj.EastAsia;
    if not ifnil(_obj.EastAsiaTheme) then
        {self.}EastAsiaTheme := _obj.EastAsiaTheme;
    if not ifnil(_obj.HAnsi) then
        {self.}HAnsi := _obj.HAnsi;
    if not ifnil(_obj.HAnsiTheme) then
        {self.}HAnsiTheme := _obj.HAnsiTheme;
    if not ifnil(_obj.Cs) then
        {self.}Cs := _obj.Cs;
    if not ifnil(_obj.CsTheme) then
        {self.}CsTheme := _obj.CsTheme;
    tslassigning := tslassigning_backup;
end;

function RFonts.ConvertToPoint();override;
begin

end;

function RFonts.ReadXmlAttrHint();
begin
    return ifnil({self.}XmlAttrHint.Value) ? fallback_.XmlAttrHint.Value : {self.}XmlAttrHint.Value;
end;

function RFonts.WriteXmlAttrHint(_value: any);
begin
    if ifnil({self.}XmlAttrHint) then
    begin
        {self.}XmlAttrHint := new OpenXmlAttribute({self.}Prefix, "hint", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "hint" : "hint"] := {self.}XmlAttrHint;
    end
    {self.}XmlAttrHint.Value := _value;
end;

function RFonts.ReadXmlAttrAscii();
begin
    return ifnil({self.}XmlAttrAscii.Value) ? fallback_.XmlAttrAscii.Value : {self.}XmlAttrAscii.Value;
end;

function RFonts.WriteXmlAttrAscii(_value: any);
begin
    if ifnil({self.}XmlAttrAscii) then
    begin
        {self.}XmlAttrAscii := new OpenXmlAttribute({self.}Prefix, "ascii", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "ascii" : "ascii"] := {self.}XmlAttrAscii;
    end
    {self.}XmlAttrAscii.Value := _value;
end;

function RFonts.ReadXmlAttrAsciiTheme();
begin
    return ifnil({self.}XmlAttrAsciiTheme.Value) ? fallback_.XmlAttrAsciiTheme.Value : {self.}XmlAttrAsciiTheme.Value;
end;

function RFonts.WriteXmlAttrAsciiTheme(_value: any);
begin
    if ifnil({self.}XmlAttrAsciiTheme) then
    begin
        {self.}XmlAttrAsciiTheme := new OpenXmlAttribute({self.}Prefix, "asciiTheme", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "asciiTheme" : "asciiTheme"] := {self.}XmlAttrAsciiTheme;
    end
    {self.}XmlAttrAsciiTheme.Value := _value;
end;

function RFonts.ReadXmlAttrEastAsia();
begin
    return ifnil({self.}XmlAttrEastAsia.Value) ? fallback_.XmlAttrEastAsia.Value : {self.}XmlAttrEastAsia.Value;
end;

function RFonts.WriteXmlAttrEastAsia(_value: any);
begin
    if ifnil({self.}XmlAttrEastAsia) then
    begin
        {self.}XmlAttrEastAsia := new OpenXmlAttribute({self.}Prefix, "eastAsia", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "eastAsia" : "eastAsia"] := {self.}XmlAttrEastAsia;
    end
    {self.}XmlAttrEastAsia.Value := _value;
end;

function RFonts.ReadXmlAttrEastAsiaTheme();
begin
    return ifnil({self.}XmlAttrEastAsiaTheme.Value) ? fallback_.XmlAttrEastAsiaTheme.Value : {self.}XmlAttrEastAsiaTheme.Value;
end;

function RFonts.WriteXmlAttrEastAsiaTheme(_value: any);
begin
    if ifnil({self.}XmlAttrEastAsiaTheme) then
    begin
        {self.}XmlAttrEastAsiaTheme := new OpenXmlAttribute({self.}Prefix, "eastAsiaTheme", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "eastAsiaTheme" : "eastAsiaTheme"] := {self.}XmlAttrEastAsiaTheme;
    end
    {self.}XmlAttrEastAsiaTheme.Value := _value;
end;

function RFonts.ReadXmlAttrHAnsi();
begin
    return ifnil({self.}XmlAttrHAnsi.Value) ? fallback_.XmlAttrHAnsi.Value : {self.}XmlAttrHAnsi.Value;
end;

function RFonts.WriteXmlAttrHAnsi(_value: any);
begin
    if ifnil({self.}XmlAttrHAnsi) then
    begin
        {self.}XmlAttrHAnsi := new OpenXmlAttribute({self.}Prefix, "hAnsi", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "hAnsi" : "hAnsi"] := {self.}XmlAttrHAnsi;
    end
    {self.}XmlAttrHAnsi.Value := _value;
end;

function RFonts.ReadXmlAttrHAnsiTheme();
begin
    return ifnil({self.}XmlAttrHAnsiTheme.Value) ? fallback_.XmlAttrHAnsiTheme.Value : {self.}XmlAttrHAnsiTheme.Value;
end;

function RFonts.WriteXmlAttrHAnsiTheme(_value: any);
begin
    if ifnil({self.}XmlAttrHAnsiTheme) then
    begin
        {self.}XmlAttrHAnsiTheme := new OpenXmlAttribute({self.}Prefix, "hAnsiTheme", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "hAnsiTheme" : "hAnsiTheme"] := {self.}XmlAttrHAnsiTheme;
    end
    {self.}XmlAttrHAnsiTheme.Value := _value;
end;

function RFonts.ReadXmlAttrCs();
begin
    return ifnil({self.}XmlAttrCs.Value) ? fallback_.XmlAttrCs.Value : {self.}XmlAttrCs.Value;
end;

function RFonts.WriteXmlAttrCs(_value: any);
begin
    if ifnil({self.}XmlAttrCs) then
    begin
        {self.}XmlAttrCs := new OpenXmlAttribute({self.}Prefix, "cs", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "cs" : "cs"] := {self.}XmlAttrCs;
    end
    {self.}XmlAttrCs.Value := _value;
end;

function RFonts.ReadXmlAttrCsTheme();
begin
    return ifnil({self.}XmlAttrCsTheme.Value) ? fallback_.XmlAttrCsTheme.Value : {self.}XmlAttrCsTheme.Value;
end;

function RFonts.WriteXmlAttrCsTheme(_value: any);
begin
    if ifnil({self.}XmlAttrCsTheme) then
    begin
        {self.}XmlAttrCsTheme := new OpenXmlAttribute({self.}Prefix, "cstheme", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "cstheme" : "cstheme"] := {self.}XmlAttrCsTheme;
    end
    {self.}XmlAttrCsTheme.Value := _value;
end;

function SzCs.Create();overload;
begin
    {self.}Create(nil, "w", "szCs");
end;

function SzCs.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function SzCs.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function SzCs.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "w:val": makeweakref(thisFunction(WriteXmlAttrVal)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function SzCs.Copy(_obj: SzCs);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    tslassigning := tslassigning_backup;
end;

function SzCs.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrVal) then
        {self.}Val := TSSafeUnitConverter.HalfPointToPoints({self.}XmlAttrVal.Value);
end;

function SzCs.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function SzCs.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute("w", "val", nil);
        attributes_["w:val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function Sz.Create();overload;
begin
    {self.}Create(nil, "w", "sz");
end;

function Sz.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Sz.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Sz.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "w:val": makeweakref(thisFunction(WriteXmlAttrVal)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Sz.Copy(_obj: Sz);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    tslassigning := tslassigning_backup;
end;

function Sz.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrVal) then
        {self.}Val := TSSafeUnitConverter.HalfPointToPoints({self.}XmlAttrVal.Value);
end;

function Sz.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function Sz.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute("w", "val", nil);
        attributes_["w:val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function PureVal.Create();overload;
begin
    {self.}Create(nil, "", "");
end;

function PureVal.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function PureVal.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function PureVal.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "val": makeweakref(thisFunction(WriteXmlAttrVal)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function PureVal.Copy(_obj: PureVal);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    tslassigning := tslassigning_backup;
end;

function PureVal.ConvertToPoint();override;
begin

end;

function PureVal.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function PureVal.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute("", "val", nil);
        attributes_["val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function PureWVal.Create();overload;
begin
    {self.}Create(nil, "", "");
end;

function PureWVal.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function PureWVal.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function PureWVal.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "w:val": makeweakref(thisFunction(WriteXmlAttrVal)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function PureWVal.Copy(_obj: PureWVal);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    tslassigning := tslassigning_backup;
end;

function PureWVal.ConvertToPoint();override;
begin

end;

function PureWVal.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function PureWVal.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute("w", "val", nil);
        attributes_["w:val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function Color.Create();overload;
begin
    {self.}Create(nil, "w", "color");
end;

function Color.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Color.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Color.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "val": makeweakref(thisFunction(WriteXmlAttrVal)),
        pre + "themeColor": makeweakref(thisFunction(WriteXmlAttrThemeColor)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Color.Copy(_obj: Color);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    if not ifnil(_obj.ThemeColor) then
        {self.}ThemeColor := _obj.ThemeColor;
    tslassigning := tslassigning_backup;
end;

function Color.ConvertToPoint();override;
begin

end;

function Color.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function Color.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute({self.}Prefix, "val", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "val" : "val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function Color.ReadXmlAttrThemeColor();
begin
    return ifnil({self.}XmlAttrThemeColor.Value) ? fallback_.XmlAttrThemeColor.Value : {self.}XmlAttrThemeColor.Value;
end;

function Color.WriteXmlAttrThemeColor(_value: any);
begin
    if ifnil({self.}XmlAttrThemeColor) then
    begin
        {self.}XmlAttrThemeColor := new OpenXmlAttribute({self.}Prefix, "themeColor", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeColor" : "themeColor"] := {self.}XmlAttrThemeColor;
    end
    {self.}XmlAttrThemeColor.Value := _value;
end;

function Lang.Create();overload;
begin
    {self.}Create(nil, "w", "lang");
end;

function Lang.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Lang.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Lang.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "val": makeweakref(thisFunction(WriteXmlAttrVal)),
        pre + "eastAsia": makeweakref(thisFunction(WriteXmlAttrEastAsia)),
        pre + "bidi": makeweakref(thisFunction(WriteXmlAttrBidi)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Lang.Copy(_obj: Lang);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    if not ifnil(_obj.EastAsia) then
        {self.}EastAsia := _obj.EastAsia;
    if not ifnil(_obj.Bidi) then
        {self.}Bidi := _obj.Bidi;
    tslassigning := tslassigning_backup;
end;

function Lang.ConvertToPoint();override;
begin

end;

function Lang.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function Lang.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute({self.}Prefix, "val", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "val" : "val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function Lang.ReadXmlAttrEastAsia();
begin
    return ifnil({self.}XmlAttrEastAsia.Value) ? fallback_.XmlAttrEastAsia.Value : {self.}XmlAttrEastAsia.Value;
end;

function Lang.WriteXmlAttrEastAsia(_value: any);
begin
    if ifnil({self.}XmlAttrEastAsia) then
    begin
        {self.}XmlAttrEastAsia := new OpenXmlAttribute({self.}Prefix, "eastAsia", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "eastAsia" : "eastAsia"] := {self.}XmlAttrEastAsia;
    end
    {self.}XmlAttrEastAsia.Value := _value;
end;

function Lang.ReadXmlAttrBidi();
begin
    return ifnil({self.}XmlAttrBidi.Value) ? fallback_.XmlAttrBidi.Value : {self.}XmlAttrBidi.Value;
end;

function Lang.WriteXmlAttrBidi(_value: any);
begin
    if ifnil({self.}XmlAttrBidi) then
    begin
        {self.}XmlAttrBidi := new OpenXmlAttribute({self.}Prefix, "bidi", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "bidi" : "bidi"] := {self.}XmlAttrBidi;
    end
    {self.}XmlAttrBidi.Value := _value;
end;

function R.Create();overload;
begin
    {self.}Create(nil, "w", "r");
end;

function R.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function R.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function R.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "rsidRPr": makeweakref(thisFunction(WriteXmlAttrRsidRPr)),
        pre + "anchor": makeweakref(thisFunction(WriteXmlAttrAnchor)),
        pre + "history": makeweakref(thisFunction(WriteXmlAttrHistory)),
    );
    sorted_child_ := array(
        pre + "r": array(0, makeweakref(thisFunction(AppendR))),
        pre + "rPr": array(1, makeweakref(thisFunction(ReadXmlChildRPr))),
        pre + "br": array(2, makeweakref(thisFunction(ReadXmlChildBr))),
        pre + "fldChar": array(3, makeweakref(thisFunction(ReadXmlChildFldChar))),
        pre + "instrText": array(4, makeweakref(thisFunction(ReadXmlChildInstrText))),
        pre + "separator": array(5, makeweakref(thisFunction(ReadXmlChildSeparator))),
        pre + "continuationSeparator": array(6, makeweakref(thisFunction(ReadXmlChildContinuationSeparator))),
        pre + "lastRenderedPageBreak": array(7, makeweakref(thisFunction(ReadXmlChildLastRenderedPageBreak))),
        "mc:AlternateContent": array(8, makeweakref(thisFunction(ReadXmlChildAlternateContent))),
        pre + "drawing": array(9, makeweakref(thisFunction(ReadXmlChildDrawing))),
        pre + "pict": array(10, makeweakref(thisFunction(ReadXmlChildPict))),
        pre + "t": array(11, makeweakref(thisFunction(ReadXmlChildT))),
        pre + "object": array(12, makeweakref(thisFunction(ReadXmlChildObject))),
        pre + "footnoteReference": array(13, makeweakref(thisFunction(ReadXmlChildFootnoteReference))),
        pre + "footnoteRef": array(14, makeweakref(thisFunction(ReadXmlChildFootnoteRef))),
        pre + "commentReference": array(15, makeweakref(thisFunction(ReadXmlChildCommentReference))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function R.Copy(_obj: R);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.RsidRPr) then
        {self.}RsidRPr := _obj.RsidRPr;
    if not ifnil(_obj.Anchor) then
        {self.}Anchor := _obj.Anchor;
    if not ifnil(_obj.History) then
        {self.}History := _obj.History;
    if not ifnil(_obj.XmlChildRPr) then
        {self.}RPr.Copy(_obj.XmlChildRPr);
    if not ifnil(_obj.XmlChildBr) then
        {self.}Br.Copy(_obj.XmlChildBr);
    if not ifnil(_obj.XmlChildFldChar) then
        {self.}FldChar.Copy(_obj.XmlChildFldChar);
    if not ifnil(_obj.XmlChildInstrText) then
        {self.}InstrText.Copy(_obj.XmlChildInstrText);
    if not ifnil(_obj.XmlChildSeparator) then
        ifnil({self.}XmlChildSeparator) ? {self.}Separator.Copy(_obj.XmlChildSeparator) : {self.}XmlChildSeparator.Copy(_obj.XmlChildSeparator);
    if not ifnil(_obj.XmlChildContinuationSeparator) then
        ifnil({self.}XmlChildContinuationSeparator) ? {self.}ContinuationSeparator.Copy(_obj.XmlChildContinuationSeparator) : {self.}XmlChildContinuationSeparator.Copy(_obj.XmlChildContinuationSeparator);
    if not ifnil(_obj.XmlChildLastRenderedPageBreak) then
        ifnil({self.}XmlChildLastRenderedPageBreak) ? {self.}LastRenderedPageBreak.Copy(_obj.XmlChildLastRenderedPageBreak) : {self.}XmlChildLastRenderedPageBreak.Copy(_obj.XmlChildLastRenderedPageBreak);
    if not ifnil(_obj.XmlChildAlternateContent) then
        {self.}AlternateContent.Copy(_obj.XmlChildAlternateContent);
    if not ifnil(_obj.XmlChildDrawing) then
        {self.}Drawing.Copy(_obj.XmlChildDrawing);
    if not ifnil(_obj.XmlChildPict) then
        {self.}Pict.Copy(_obj.XmlChildPict);
    if not ifnil(_obj.XmlChildT) then
        {self.}T.Copy(_obj.XmlChildT);
    if not ifnil(_obj.XmlChildObject) then
        {self.}Object.Copy(_obj.XmlChildObject);
    if not ifnil(_obj.XmlChildFootnoteReference) then
        {self.}FootnoteReference.Copy(_obj.XmlChildFootnoteReference);
    if not ifnil(_obj.XmlChildFootnoteRef) then
        ifnil({self.}XmlChildFootnoteRef) ? {self.}FootnoteRef.Copy(_obj.XmlChildFootnoteRef) : {self.}XmlChildFootnoteRef.Copy(_obj.XmlChildFootnoteRef);
    if not ifnil(_obj.XmlChildCommentReference) then
        {self.}CommentReference.Copy(_obj.XmlChildCommentReference);
    tslassigning := tslassigning_backup;
end;

function R.ConvertToPoint();override;
begin
    elems := {self.}Rs();
    for _,elem in elems do
        elem.ConvertToPoint();
    if not ifnil({self.}XmlChildRPr) then
        {self.}XmlChildRPr.ConvertToPoint();
    if not ifnil({self.}XmlChildBr) then
        {self.}XmlChildBr.ConvertToPoint();
    if not ifnil({self.}XmlChildFldChar) then
        {self.}XmlChildFldChar.ConvertToPoint();
    if not ifnil({self.}XmlChildInstrText) then
        {self.}XmlChildInstrText.ConvertToPoint();
    if not ifnil({self.}XmlChildAlternateContent) then
        {self.}XmlChildAlternateContent.ConvertToPoint();
    if not ifnil({self.}XmlChildDrawing) then
        {self.}XmlChildDrawing.ConvertToPoint();
    if not ifnil({self.}XmlChildPict) then
        {self.}XmlChildPict.ConvertToPoint();
    if not ifnil({self.}XmlChildT) then
        {self.}XmlChildT.ConvertToPoint();
    if not ifnil({self.}XmlChildObject) then
        {self.}XmlChildObject.ConvertToPoint();
    if not ifnil({self.}XmlChildFootnoteReference) then
        {self.}XmlChildFootnoteReference.ConvertToPoint();
    if not ifnil({self.}XmlChildCommentReference) then
        {self.}XmlChildCommentReference.ConvertToPoint();
end;

function R.ReadXmlAttrRsidRPr();
begin
    return ifnil({self.}XmlAttrRsidRPr.Value) ? fallback_.XmlAttrRsidRPr.Value : {self.}XmlAttrRsidRPr.Value;
end;

function R.WriteXmlAttrRsidRPr(_value: any);
begin
    if ifnil({self.}XmlAttrRsidRPr) then
    begin
        {self.}XmlAttrRsidRPr := new OpenXmlAttribute({self.}Prefix, "rsidRPr", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "rsidRPr" : "rsidRPr"] := {self.}XmlAttrRsidRPr;
    end
    {self.}XmlAttrRsidRPr.Value := _value;
end;

function R.ReadXmlAttrAnchor();
begin
    return ifnil({self.}XmlAttrAnchor.Value) ? fallback_.XmlAttrAnchor.Value : {self.}XmlAttrAnchor.Value;
end;

function R.WriteXmlAttrAnchor(_value: any);
begin
    if ifnil({self.}XmlAttrAnchor) then
    begin
        {self.}XmlAttrAnchor := new OpenXmlAttribute({self.}Prefix, "anchor", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "anchor" : "anchor"] := {self.}XmlAttrAnchor;
    end
    {self.}XmlAttrAnchor.Value := _value;
end;

function R.ReadXmlAttrHistory();
begin
    return ifnil({self.}XmlAttrHistory.Value) ? fallback_.XmlAttrHistory.Value : {self.}XmlAttrHistory.Value;
end;

function R.WriteXmlAttrHistory(_value: any);
begin
    if ifnil({self.}XmlAttrHistory) then
    begin
        {self.}XmlAttrHistory := new OpenXmlAttribute({self.}Prefix, "history", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "history" : "history"] := {self.}XmlAttrHistory;
    end
    {self.}XmlAttrHistory.Value := _value;
end;

function R.ReadXmlChildSeparator();
begin
    if tslassigning and (ifnil({self.}XmlChildSeparator) or {self.}XmlChildSeparator.Removed) then
    begin
        {self.}XmlChildSeparator := new OpenXmlSimpleType(self, {self.}Prefix, "separator");
        container_.Set({self.}XmlChildSeparator);
    end
    return {self.}XmlChildSeparator and not {self.}XmlChildSeparator.Removed ? {self.}XmlChildSeparator : fallback_.XmlChildSeparator;
end;

function R.WriteXmlChildSeparator(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildSeparator) then
            {self.}RemoveChild({self.}XmlChildSeparator);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildSeparator := _value;
        container_.Set({self.}XmlChildSeparator);
    end
    else begin
        raise "Invalid assignment: Separator expects nil or OpenXmlSimpleType";
    end
end;

function R.ReadXmlChildContinuationSeparator();
begin
    if tslassigning and (ifnil({self.}XmlChildContinuationSeparator) or {self.}XmlChildContinuationSeparator.Removed) then
    begin
        {self.}XmlChildContinuationSeparator := new OpenXmlSimpleType(self, {self.}Prefix, "continuationSeparator");
        container_.Set({self.}XmlChildContinuationSeparator);
    end
    return {self.}XmlChildContinuationSeparator and not {self.}XmlChildContinuationSeparator.Removed ? {self.}XmlChildContinuationSeparator : fallback_.XmlChildContinuationSeparator;
end;

function R.WriteXmlChildContinuationSeparator(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildContinuationSeparator) then
            {self.}RemoveChild({self.}XmlChildContinuationSeparator);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildContinuationSeparator := _value;
        container_.Set({self.}XmlChildContinuationSeparator);
    end
    else begin
        raise "Invalid assignment: ContinuationSeparator expects nil or OpenXmlSimpleType";
    end
end;

function R.ReadXmlChildLastRenderedPageBreak();
begin
    if tslassigning and (ifnil({self.}XmlChildLastRenderedPageBreak) or {self.}XmlChildLastRenderedPageBreak.Removed) then
    begin
        {self.}XmlChildLastRenderedPageBreak := new OpenXmlSimpleType(self, {self.}Prefix, "lastRenderedPageBreak");
        container_.Set({self.}XmlChildLastRenderedPageBreak);
    end
    return {self.}XmlChildLastRenderedPageBreak and not {self.}XmlChildLastRenderedPageBreak.Removed ? {self.}XmlChildLastRenderedPageBreak : fallback_.XmlChildLastRenderedPageBreak;
end;

function R.WriteXmlChildLastRenderedPageBreak(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildLastRenderedPageBreak) then
            {self.}RemoveChild({self.}XmlChildLastRenderedPageBreak);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildLastRenderedPageBreak := _value;
        container_.Set({self.}XmlChildLastRenderedPageBreak);
    end
    else begin
        raise "Invalid assignment: LastRenderedPageBreak expects nil or OpenXmlSimpleType";
    end
end;

function R.ReadXmlChildFootnoteRef();
begin
    if tslassigning and (ifnil({self.}XmlChildFootnoteRef) or {self.}XmlChildFootnoteRef.Removed) then
    begin
        {self.}XmlChildFootnoteRef := new OpenXmlSimpleType(self, {self.}Prefix, "footnoteRef");
        container_.Set({self.}XmlChildFootnoteRef);
    end
    return {self.}XmlChildFootnoteRef and not {self.}XmlChildFootnoteRef.Removed ? {self.}XmlChildFootnoteRef : fallback_.XmlChildFootnoteRef;
end;

function R.WriteXmlChildFootnoteRef(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildFootnoteRef) then
            {self.}RemoveChild({self.}XmlChildFootnoteRef);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildFootnoteRef := _value;
        container_.Set({self.}XmlChildFootnoteRef);
    end
    else begin
        raise "Invalid assignment: FootnoteRef expects nil or OpenXmlSimpleType";
    end
end;

function R.ReadXmlChildRPr(): RPr;
begin
    if tslassigning and (ifnil({self.}XmlChildRPr) or {self.}XmlChildRPr.Removed) then
    begin
        {self.}XmlChildRPr := new RPr(self, {self.}Prefix, "rPr");
        container_.Set({self.}XmlChildRPr);
    end
    return {self.}XmlChildRPr and not {self.}XmlChildRPr.Removed ? {self.}XmlChildRPr : fallback_.XmlChildRPr;
end;

function R.WriteXmlChildRPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRPr) then
            {self.}RemoveChild({self.}XmlChildRPr);
    end
    else if v is class(RPr) then
    begin
        {self.}XmlChildRPr := v;
        container_.Set({self.}XmlChildRPr);
    end
    else begin
        raise "Invalid assignment: RPr expects RPr or nil";
    end
end;

function R.ReadXmlChildBr(): Br;
begin
    if tslassigning and (ifnil({self.}XmlChildBr) or {self.}XmlChildBr.Removed) then
    begin
        {self.}XmlChildBr := new Br(self, {self.}Prefix, "br");
        container_.Set({self.}XmlChildBr);
    end
    return {self.}XmlChildBr and not {self.}XmlChildBr.Removed ? {self.}XmlChildBr : fallback_.XmlChildBr;
end;

function R.WriteXmlChildBr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildBr) then
            {self.}RemoveChild({self.}XmlChildBr);
    end
    else if v is class(Br) then
    begin
        {self.}XmlChildBr := v;
        container_.Set({self.}XmlChildBr);
    end
    else begin
        raise "Invalid assignment: Br expects Br or nil";
    end
end;

function R.ReadXmlChildFldChar(): FldChar;
begin
    if tslassigning and (ifnil({self.}XmlChildFldChar) or {self.}XmlChildFldChar.Removed) then
    begin
        {self.}XmlChildFldChar := new FldChar(self, {self.}Prefix, "fldChar");
        container_.Set({self.}XmlChildFldChar);
    end
    return {self.}XmlChildFldChar and not {self.}XmlChildFldChar.Removed ? {self.}XmlChildFldChar : fallback_.XmlChildFldChar;
end;

function R.WriteXmlChildFldChar(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildFldChar) then
            {self.}RemoveChild({self.}XmlChildFldChar);
    end
    else if v is class(FldChar) then
    begin
        {self.}XmlChildFldChar := v;
        container_.Set({self.}XmlChildFldChar);
    end
    else begin
        raise "Invalid assignment: FldChar expects FldChar or nil";
    end
end;

function R.ReadXmlChildInstrText(): InstrText;
begin
    if tslassigning and (ifnil({self.}XmlChildInstrText) or {self.}XmlChildInstrText.Removed) then
    begin
        {self.}XmlChildInstrText := new InstrText(self, {self.}Prefix, "instrText");
        container_.Set({self.}XmlChildInstrText);
    end
    return {self.}XmlChildInstrText and not {self.}XmlChildInstrText.Removed ? {self.}XmlChildInstrText : fallback_.XmlChildInstrText;
end;

function R.WriteXmlChildInstrText(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildInstrText) then
            {self.}RemoveChild({self.}XmlChildInstrText);
    end
    else if v is class(InstrText) then
    begin
        {self.}XmlChildInstrText := v;
        container_.Set({self.}XmlChildInstrText);
    end
    else begin
        raise "Invalid assignment: InstrText expects InstrText or nil";
    end
end;

function R.ReadXmlChildAlternateContent(): AlternateContent;
begin
    if tslassigning and (ifnil({self.}XmlChildAlternateContent) or {self.}XmlChildAlternateContent.Removed) then
    begin
        {self.}XmlChildAlternateContent := new AlternateContent(self, "mc", "AlternateContent");
        container_.Set({self.}XmlChildAlternateContent);
    end
    return {self.}XmlChildAlternateContent and not {self.}XmlChildAlternateContent.Removed ? {self.}XmlChildAlternateContent : fallback_.XmlChildAlternateContent;
end;

function R.WriteXmlChildAlternateContent(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildAlternateContent) then
            {self.}RemoveChild({self.}XmlChildAlternateContent);
    end
    else if v is class(AlternateContent) then
    begin
        {self.}XmlChildAlternateContent := v;
        container_.Set({self.}XmlChildAlternateContent);
    end
    else begin
        raise "Invalid assignment: AlternateContent expects AlternateContent or nil";
    end
end;

function R.ReadXmlChildDrawing(): Drawing;
begin
    if tslassigning and (ifnil({self.}XmlChildDrawing) or {self.}XmlChildDrawing.Removed) then
    begin
        {self.}XmlChildDrawing := new Drawing(self, {self.}Prefix, "drawing");
        container_.Set({self.}XmlChildDrawing);
    end
    return {self.}XmlChildDrawing and not {self.}XmlChildDrawing.Removed ? {self.}XmlChildDrawing : fallback_.XmlChildDrawing;
end;

function R.WriteXmlChildDrawing(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildDrawing) then
            {self.}RemoveChild({self.}XmlChildDrawing);
    end
    else if v is class(Drawing) then
    begin
        {self.}XmlChildDrawing := v;
        container_.Set({self.}XmlChildDrawing);
    end
    else begin
        raise "Invalid assignment: Drawing expects Drawing or nil";
    end
end;

function R.ReadXmlChildPict(): Pict;
begin
    if tslassigning and (ifnil({self.}XmlChildPict) or {self.}XmlChildPict.Removed) then
    begin
        {self.}XmlChildPict := new Pict(self, {self.}Prefix, "pict");
        container_.Set({self.}XmlChildPict);
    end
    return {self.}XmlChildPict and not {self.}XmlChildPict.Removed ? {self.}XmlChildPict : fallback_.XmlChildPict;
end;

function R.WriteXmlChildPict(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPict) then
            {self.}RemoveChild({self.}XmlChildPict);
    end
    else if v is class(Pict) then
    begin
        {self.}XmlChildPict := v;
        container_.Set({self.}XmlChildPict);
    end
    else begin
        raise "Invalid assignment: Pict expects Pict or nil";
    end
end;

function R.ReadXmlChildT(): T;
begin
    if tslassigning and (ifnil({self.}XmlChildT) or {self.}XmlChildT.Removed) then
    begin
        {self.}XmlChildT := new T(self, {self.}Prefix, "t");
        container_.Set({self.}XmlChildT);
    end
    return {self.}XmlChildT and not {self.}XmlChildT.Removed ? {self.}XmlChildT : fallback_.XmlChildT;
end;

function R.WriteXmlChildT(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildT) then
            {self.}RemoveChild({self.}XmlChildT);
    end
    else if v is class(T) then
    begin
        {self.}XmlChildT := v;
        container_.Set({self.}XmlChildT);
    end
    else begin
        raise "Invalid assignment: T expects T or nil";
    end
end;

function R.ReadXmlChildObject(): Object;
begin
    if tslassigning and (ifnil({self.}XmlChildObject) or {self.}XmlChildObject.Removed) then
    begin
        {self.}XmlChildObject := new Object(self, {self.}Prefix, "object");
        container_.Set({self.}XmlChildObject);
    end
    return {self.}XmlChildObject and not {self.}XmlChildObject.Removed ? {self.}XmlChildObject : fallback_.XmlChildObject;
end;

function R.WriteXmlChildObject(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildObject) then
            {self.}RemoveChild({self.}XmlChildObject);
    end
    else if v is class(Object) then
    begin
        {self.}XmlChildObject := v;
        container_.Set({self.}XmlChildObject);
    end
    else begin
        raise "Invalid assignment: Object expects Object or nil";
    end
end;

function R.ReadXmlChildFootnoteReference(): FootnoteReference;
begin
    if tslassigning and (ifnil({self.}XmlChildFootnoteReference) or {self.}XmlChildFootnoteReference.Removed) then
    begin
        {self.}XmlChildFootnoteReference := new FootnoteReference(self, {self.}Prefix, "footnoteReference");
        container_.Set({self.}XmlChildFootnoteReference);
    end
    return {self.}XmlChildFootnoteReference and not {self.}XmlChildFootnoteReference.Removed ? {self.}XmlChildFootnoteReference : fallback_.XmlChildFootnoteReference;
end;

function R.WriteXmlChildFootnoteReference(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildFootnoteReference) then
            {self.}RemoveChild({self.}XmlChildFootnoteReference);
    end
    else if v is class(FootnoteReference) then
    begin
        {self.}XmlChildFootnoteReference := v;
        container_.Set({self.}XmlChildFootnoteReference);
    end
    else begin
        raise "Invalid assignment: FootnoteReference expects FootnoteReference or nil";
    end
end;

function R.ReadXmlChildCommentReference(): CommentReference;
begin
    if tslassigning and (ifnil({self.}XmlChildCommentReference) or {self.}XmlChildCommentReference.Removed) then
    begin
        {self.}XmlChildCommentReference := new CommentReference(self, {self.}Prefix, "commentReference");
        container_.Set({self.}XmlChildCommentReference);
    end
    return {self.}XmlChildCommentReference and not {self.}XmlChildCommentReference.Removed ? {self.}XmlChildCommentReference : fallback_.XmlChildCommentReference;
end;

function R.WriteXmlChildCommentReference(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildCommentReference) then
            {self.}RemoveChild({self.}XmlChildCommentReference);
    end
    else if v is class(CommentReference) then
    begin
        {self.}XmlChildCommentReference := v;
        container_.Set({self.}XmlChildCommentReference);
    end
    else begin
        raise "Invalid assignment: CommentReference expects CommentReference or nil";
    end
end;

function R.ReadRs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "r", ind);
end;

function R.WriteRs(_index: integer; _value: nil_OR_R);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadRs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "r", ind, _value) then
            raise format("Index out of range: Rs[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Rs expects nil or R";
    end
end;

function R.AddR(): R;
begin
    obj := new R(self, {self.}Prefix, "r");
    container_.Insert(obj);
    return obj;
end;

function R.AppendR(): R;
begin
    obj := new R(self, {self.}Prefix, "r");
    container_.Append(obj);
    return obj;
end;

function CommentReference.Create();overload;
begin
    {self.}Create(nil, "w", "commentReference");
end;

function CommentReference.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function CommentReference.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function CommentReference.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "id": makeweakref(thisFunction(WriteXmlAttrId)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function CommentReference.Copy(_obj: CommentReference);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Id) then
        {self.}Id := _obj.Id;
    tslassigning := tslassigning_backup;
end;

function CommentReference.ConvertToPoint();override;
begin

end;

function CommentReference.ReadXmlAttrId();
begin
    return ifnil({self.}XmlAttrId.Value) ? fallback_.XmlAttrId.Value : {self.}XmlAttrId.Value;
end;

function CommentReference.WriteXmlAttrId(_value: any);
begin
    if ifnil({self.}XmlAttrId) then
    begin
        {self.}XmlAttrId := new OpenXmlAttribute({self.}Prefix, "id", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "id" : "id"] := {self.}XmlAttrId;
    end
    {self.}XmlAttrId.Value := _value;
end;

function Object.Create();overload;
begin
    {self.}Create(nil, "w", "object");
end;

function Object.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Object.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Object.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "dxaOrig": makeweakref(thisFunction(WriteXmlAttrDxaOrig)),
        pre + "dyaOrig": makeweakref(thisFunction(WriteXmlAttrDyaOrig)),
        "w14:anchorId": makeweakref(thisFunction(WriteXmlAttrAnchorId)),
    );
    sorted_child_ := array(
        "v:shapetype": array(0, makeweakref(thisFunction(ReadXmlChildShapetype))),
        "v:shape": array(1, makeweakref(thisFunction(ReadXmlChildShape))),
        "o:OLEObject": array(2, makeweakref(thisFunction(ReadXmlChildOLEObject))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Object.Copy(_obj: Object);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.DxaOrig) then
        {self.}DxaOrig := _obj.DxaOrig;
    if not ifnil(_obj.DyaOrig) then
        {self.}DyaOrig := _obj.DyaOrig;
    if not ifnil(_obj.AnchorId) then
        {self.}AnchorId := _obj.AnchorId;
    if not ifnil(_obj.XmlChildShapetype) then
        {self.}Shapetype.Copy(_obj.XmlChildShapetype);
    if not ifnil(_obj.XmlChildShape) then
        {self.}Shape.Copy(_obj.XmlChildShape);
    if not ifnil(_obj.XmlChildOLEObject) then
        {self.}OLEObject.Copy(_obj.XmlChildOLEObject);
    tslassigning := tslassigning_backup;
end;

function Object.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrDxaOrig) then
        {self.}DxaOrig := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrDxaOrig.Value);
    if not ifnil({self.}XmlAttrDyaOrig) then
        {self.}DyaOrig := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrDyaOrig.Value);
    if not ifnil({self.}XmlChildShapetype) then
        {self.}XmlChildShapetype.ConvertToPoint();
    if not ifnil({self.}XmlChildShape) then
        {self.}XmlChildShape.ConvertToPoint();
    if not ifnil({self.}XmlChildOLEObject) then
        {self.}XmlChildOLEObject.ConvertToPoint();
end;

function Object.ReadXmlAttrDxaOrig();
begin
    return ifnil({self.}XmlAttrDxaOrig.Value) ? fallback_.XmlAttrDxaOrig.Value : {self.}XmlAttrDxaOrig.Value;
end;

function Object.WriteXmlAttrDxaOrig(_value: any);
begin
    if ifnil({self.}XmlAttrDxaOrig) then
    begin
        {self.}XmlAttrDxaOrig := new OpenXmlAttribute({self.}Prefix, "dxaOrig", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "dxaOrig" : "dxaOrig"] := {self.}XmlAttrDxaOrig;
    end
    {self.}XmlAttrDxaOrig.Value := _value;
end;

function Object.ReadXmlAttrDyaOrig();
begin
    return ifnil({self.}XmlAttrDyaOrig.Value) ? fallback_.XmlAttrDyaOrig.Value : {self.}XmlAttrDyaOrig.Value;
end;

function Object.WriteXmlAttrDyaOrig(_value: any);
begin
    if ifnil({self.}XmlAttrDyaOrig) then
    begin
        {self.}XmlAttrDyaOrig := new OpenXmlAttribute({self.}Prefix, "dyaOrig", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "dyaOrig" : "dyaOrig"] := {self.}XmlAttrDyaOrig;
    end
    {self.}XmlAttrDyaOrig.Value := _value;
end;

function Object.ReadXmlAttrAnchorId();
begin
    return ifnil({self.}XmlAttrAnchorId.Value) ? fallback_.XmlAttrAnchorId.Value : {self.}XmlAttrAnchorId.Value;
end;

function Object.WriteXmlAttrAnchorId(_value: any);
begin
    if ifnil({self.}XmlAttrAnchorId) then
    begin
        {self.}XmlAttrAnchorId := new OpenXmlAttribute("w14", "anchorId", nil);
        attributes_["w14:anchorId"] := {self.}XmlAttrAnchorId;
    end
    {self.}XmlAttrAnchorId.Value := _value;
end;

function Object.ReadXmlChildShapetype(): Shapetype;
begin
    if tslassigning and (ifnil({self.}XmlChildShapetype) or {self.}XmlChildShapetype.Removed) then
    begin
        {self.}XmlChildShapetype := new VML.Shapetype(self, "v", "shapetype");
        container_.Set({self.}XmlChildShapetype);
    end
    return {self.}XmlChildShapetype and not {self.}XmlChildShapetype.Removed ? {self.}XmlChildShapetype : fallback_.XmlChildShapetype;
end;

function Object.WriteXmlChildShapetype(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildShapetype) then
            {self.}RemoveChild({self.}XmlChildShapetype);
    end
    else if v is class(Shapetype) then
    begin
        {self.}XmlChildShapetype := v;
        container_.Set({self.}XmlChildShapetype);
    end
    else begin
        raise "Invalid assignment: Shapetype expects Shapetype or nil";
    end
end;

function Object.ReadXmlChildShape(): Shape;
begin
    if tslassigning and (ifnil({self.}XmlChildShape) or {self.}XmlChildShape.Removed) then
    begin
        {self.}XmlChildShape := new VML.Shape(self, "v", "shape");
        container_.Set({self.}XmlChildShape);
    end
    return {self.}XmlChildShape and not {self.}XmlChildShape.Removed ? {self.}XmlChildShape : fallback_.XmlChildShape;
end;

function Object.WriteXmlChildShape(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildShape) then
            {self.}RemoveChild({self.}XmlChildShape);
    end
    else if v is class(Shape) then
    begin
        {self.}XmlChildShape := v;
        container_.Set({self.}XmlChildShape);
    end
    else begin
        raise "Invalid assignment: Shape expects Shape or nil";
    end
end;

function Object.ReadXmlChildOLEObject(): OLEObject;
begin
    if tslassigning and (ifnil({self.}XmlChildOLEObject) or {self.}XmlChildOLEObject.Removed) then
    begin
        {self.}XmlChildOLEObject := new VML.OLEObject(self, "o", "OLEObject");
        container_.Set({self.}XmlChildOLEObject);
    end
    return {self.}XmlChildOLEObject and not {self.}XmlChildOLEObject.Removed ? {self.}XmlChildOLEObject : fallback_.XmlChildOLEObject;
end;

function Object.WriteXmlChildOLEObject(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildOLEObject) then
            {self.}RemoveChild({self.}XmlChildOLEObject);
    end
    else if v is class(OLEObject) then
    begin
        {self.}XmlChildOLEObject := v;
        container_.Set({self.}XmlChildOLEObject);
    end
    else begin
        raise "Invalid assignment: OLEObject expects OLEObject or nil";
    end
end;

function FootnoteReference.Create();overload;
begin
    {self.}Create(nil, "w", "footnoteReference");
end;

function FootnoteReference.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function FootnoteReference.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function FootnoteReference.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "id": makeweakref(thisFunction(WriteXmlAttrId)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function FootnoteReference.Copy(_obj: FootnoteReference);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Id) then
        {self.}Id := _obj.Id;
    tslassigning := tslassigning_backup;
end;

function FootnoteReference.ConvertToPoint();override;
begin

end;

function FootnoteReference.ReadXmlAttrId();
begin
    return ifnil({self.}XmlAttrId.Value) ? fallback_.XmlAttrId.Value : {self.}XmlAttrId.Value;
end;

function FootnoteReference.WriteXmlAttrId(_value: any);
begin
    if ifnil({self.}XmlAttrId) then
    begin
        {self.}XmlAttrId := new OpenXmlAttribute({self.}Prefix, "id", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "id" : "id"] := {self.}XmlAttrId;
    end
    {self.}XmlAttrId.Value := _value;
end;

function FldChar.Create();overload;
begin
    {self.}Create(nil, "w", "fldChar");
end;

function FldChar.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function FldChar.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function FldChar.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "fldCharType": makeweakref(thisFunction(WriteXmlAttrFldCharType)),
        pre + "fldLock": makeweakref(thisFunction(WriteXmlAttrFldLock)),
        pre + "dirty": makeweakref(thisFunction(WriteXmlAttrDirty)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function FldChar.Copy(_obj: FldChar);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.FldCharType) then
        {self.}FldCharType := _obj.FldCharType;
    if not ifnil(_obj.FldLock) then
        {self.}FldLock := _obj.FldLock;
    if not ifnil(_obj.Dirty) then
        {self.}Dirty := _obj.Dirty;
    tslassigning := tslassigning_backup;
end;

function FldChar.ConvertToPoint();override;
begin

end;

function FldChar.ReadXmlAttrFldCharType();
begin
    return ifnil({self.}XmlAttrFldCharType.Value) ? fallback_.XmlAttrFldCharType.Value : {self.}XmlAttrFldCharType.Value;
end;

function FldChar.WriteXmlAttrFldCharType(_value: any);
begin
    if ifnil({self.}XmlAttrFldCharType) then
    begin
        {self.}XmlAttrFldCharType := new OpenXmlAttribute({self.}Prefix, "fldCharType", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "fldCharType" : "fldCharType"] := {self.}XmlAttrFldCharType;
    end
    {self.}XmlAttrFldCharType.Value := _value;
end;

function FldChar.ReadXmlAttrFldLock();
begin
    return ifnil({self.}XmlAttrFldLock.Value) ? fallback_.XmlAttrFldLock.Value : {self.}XmlAttrFldLock.Value;
end;

function FldChar.WriteXmlAttrFldLock(_value: any);
begin
    if ifnil({self.}XmlAttrFldLock) then
    begin
        {self.}XmlAttrFldLock := new OpenXmlAttribute({self.}Prefix, "fldLock", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "fldLock" : "fldLock"] := {self.}XmlAttrFldLock;
    end
    {self.}XmlAttrFldLock.Value := _value;
end;

function FldChar.ReadXmlAttrDirty();
begin
    return ifnil({self.}XmlAttrDirty.Value) ? fallback_.XmlAttrDirty.Value : {self.}XmlAttrDirty.Value;
end;

function FldChar.WriteXmlAttrDirty(_value: any);
begin
    if ifnil({self.}XmlAttrDirty) then
    begin
        {self.}XmlAttrDirty := new OpenXmlAttribute({self.}Prefix, "dirty", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "dirty" : "dirty"] := {self.}XmlAttrDirty;
    end
    {self.}XmlAttrDirty.Value := _value;
end;

function InstrText.Create();overload;
begin
    {self.}Create(nil, "w", "instrText");
end;

function InstrText.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function InstrText.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function InstrText.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "xml:Space": makeweakref(thisFunction(WriteXmlAttrSpace)),
    );
end;

function InstrText.Copy(_obj: InstrText);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlTextElement).Copy(_obj);
    if not ifnil(_obj.Space) then
        {self.}Space := _obj.Space;
    tslassigning := tslassigning_backup;
end;

function InstrText.ConvertToPoint();override;
begin

end;

function InstrText.ReadXmlAttrSpace();
begin
    return ifnil({self.}XmlAttrSpace.Value) ? fallback_.XmlAttrSpace.Value : {self.}XmlAttrSpace.Value;
end;

function InstrText.WriteXmlAttrSpace(_value: any);
begin
    if ifnil({self.}XmlAttrSpace) then
    begin
        {self.}XmlAttrSpace := new OpenXmlAttribute("xml", "Space", nil);
        attributes_["xml:Space"] := {self.}XmlAttrSpace;
    end
    {self.}XmlAttrSpace.Value := _value;
end;

function Br.Create();overload;
begin
    {self.}Create(nil, "w", "br");
end;

function Br.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Br.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Br.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "type": makeweakref(thisFunction(WriteXmlAttrType)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Br.Copy(_obj: Br);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Type) then
        {self.}Type := _obj.Type;
    tslassigning := tslassigning_backup;
end;

function Br.ConvertToPoint();override;
begin

end;

function Br.ReadXmlAttrType();
begin
    return ifnil({self.}XmlAttrType.Value) ? fallback_.XmlAttrType.Value : {self.}XmlAttrType.Value;
end;

function Br.WriteXmlAttrType(_value: any);
begin
    if ifnil({self.}XmlAttrType) then
    begin
        {self.}XmlAttrType := new OpenXmlAttribute({self.}Prefix, "type", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "type" : "type"] := {self.}XmlAttrType;
    end
    {self.}XmlAttrType.Value := _value;
end;

function TxbxContent.Create();overload;
begin
    {self.}Create(nil, "w", "textbox");
end;

function TxbxContent.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TxbxContent.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TxbxContent.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "p": array(0, makeweakref(thisFunction(AppendP))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TxbxContent.Copy(_obj: TxbxContent);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    tslassigning := tslassigning_backup;
end;

function TxbxContent.ConvertToPoint();override;
begin
    elems := {self.}Ps();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function TxbxContent.ReadPs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "p", ind);
end;

function TxbxContent.WritePs(_index: integer; _value: nil_OR_P);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadPs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "p", ind, _value) then
            raise format("Index out of range: Ps[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Ps expects nil or P";
    end
end;

function TxbxContent.AddP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Insert(obj);
    return obj;
end;

function TxbxContent.AppendP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Append(obj);
    return obj;
end;

function Drawing.Create();overload;
begin
    {self.}Create(nil, "w", "drawing");
end;

function Drawing.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Drawing.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Drawing.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        "wp:inline": array(0, makeweakref(thisFunction(ReadXmlChild_Inline))),
        "wp:anchor": array(1, makeweakref(thisFunction(ReadXmlChildAnchor))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Drawing.Copy(_obj: Drawing);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChild_Inline) then
        {self.}_Inline.Copy(_obj.XmlChild_Inline);
    if not ifnil(_obj.XmlChildAnchor) then
        {self.}Anchor.Copy(_obj.XmlChildAnchor);
    tslassigning := tslassigning_backup;
end;

function Drawing.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChild_Inline) then
        {self.}XmlChild_Inline.ConvertToPoint();
    if not ifnil({self.}XmlChildAnchor) then
        {self.}XmlChildAnchor.ConvertToPoint();
end;

function Drawing.ReadXmlChild_Inline(): _Inline;
begin
    if tslassigning and (ifnil({self.}XmlChild_Inline) or {self.}XmlChild_Inline.Removed) then
    begin
        {self.}XmlChild_Inline := new DrawingML._Inline(self, "wp", "inline");
        container_.Set({self.}XmlChild_Inline);
    end
    return {self.}XmlChild_Inline and not {self.}XmlChild_Inline.Removed ? {self.}XmlChild_Inline : fallback_.XmlChild_Inline;
end;

function Drawing.WriteXmlChild_Inline(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChild_Inline) then
            {self.}RemoveChild({self.}XmlChild_Inline);
    end
    else if v is class(_Inline) then
    begin
        {self.}XmlChild_Inline := v;
        container_.Set({self.}XmlChild_Inline);
    end
    else begin
        raise "Invalid assignment: _Inline expects _Inline or nil";
    end
end;

function Drawing.ReadXmlChildAnchor(): Anchor;
begin
    if tslassigning and (ifnil({self.}XmlChildAnchor) or {self.}XmlChildAnchor.Removed) then
    begin
        {self.}XmlChildAnchor := new DrawingML.Anchor(self, "wp", "anchor");
        container_.Set({self.}XmlChildAnchor);
    end
    return {self.}XmlChildAnchor and not {self.}XmlChildAnchor.Removed ? {self.}XmlChildAnchor : fallback_.XmlChildAnchor;
end;

function Drawing.WriteXmlChildAnchor(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildAnchor) then
            {self.}RemoveChild({self.}XmlChildAnchor);
    end
    else if v is class(Anchor) then
    begin
        {self.}XmlChildAnchor := v;
        container_.Set({self.}XmlChildAnchor);
    end
    else begin
        raise "Invalid assignment: Anchor expects Anchor or nil";
    end
end;

function T.Create();overload;
begin
    {self.}Create(nil, "w", "t");
end;

function T.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function T.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function T.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "xml:space": makeweakref(thisFunction(WriteXmlAttrSpace)),
    );
end;

function T.Copy(_obj: T);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlTextElement).Copy(_obj);
    if not ifnil(_obj.Space) then
        {self.}Space := _obj.Space;
    tslassigning := tslassigning_backup;
end;

function T.ConvertToPoint();override;
begin

end;

function T.ReadXmlAttrSpace();
begin
    return ifnil({self.}XmlAttrSpace.Value) ? fallback_.XmlAttrSpace.Value : {self.}XmlAttrSpace.Value;
end;

function T.WriteXmlAttrSpace(_value: any);
begin
    if ifnil({self.}XmlAttrSpace) then
    begin
        {self.}XmlAttrSpace := new OpenXmlAttribute("xml", "space", nil);
        attributes_["xml:space"] := {self.}XmlAttrSpace;
    end
    {self.}XmlAttrSpace.Value := _value;
end;

function Tbl.Create();overload;
begin
    {self.}Create(nil, "w", "tbl");
end;

function Tbl.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Tbl.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Tbl.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "tblPr": array(0, makeweakref(thisFunction(ReadXmlChildTblPr))),
        pre + "tblGrid": array(1, makeweakref(thisFunction(ReadXmlChildTblGrid))),
        pre + "tr": array(2, makeweakref(thisFunction(AppendTr))),
        pre + "sdt": array(3, makeweakref(thisFunction(AppendSdt))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Tbl.Copy(_obj: Tbl);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildTblPr) then
        {self.}TblPr.Copy(_obj.XmlChildTblPr);
    if not ifnil(_obj.XmlChildTblGrid) then
        {self.}TblGrid.Copy(_obj.XmlChildTblGrid);
    tslassigning := tslassigning_backup;
end;

function Tbl.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildTblPr) then
        {self.}XmlChildTblPr.ConvertToPoint();
    if not ifnil({self.}XmlChildTblGrid) then
        {self.}XmlChildTblGrid.ConvertToPoint();
    elems := {self.}Trs();
    for _,elem in elems do
        elem.ConvertToPoint();
    elems := {self.}Sdts();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Tbl.ReadXmlChildTblPr(): TblPr;
begin
    if tslassigning and (ifnil({self.}XmlChildTblPr) or {self.}XmlChildTblPr.Removed) then
    begin
        {self.}XmlChildTblPr := new TblPr(self, {self.}Prefix, "tblPr");
        container_.Set({self.}XmlChildTblPr);
    end
    return {self.}XmlChildTblPr and not {self.}XmlChildTblPr.Removed ? {self.}XmlChildTblPr : fallback_.XmlChildTblPr;
end;

function Tbl.WriteXmlChildTblPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTblPr) then
            {self.}RemoveChild({self.}XmlChildTblPr);
    end
    else if v is class(TblPr) then
    begin
        {self.}XmlChildTblPr := v;
        container_.Set({self.}XmlChildTblPr);
    end
    else begin
        raise "Invalid assignment: TblPr expects TblPr or nil";
    end
end;

function Tbl.ReadXmlChildTblGrid(): TblGrid;
begin
    if tslassigning and (ifnil({self.}XmlChildTblGrid) or {self.}XmlChildTblGrid.Removed) then
    begin
        {self.}XmlChildTblGrid := new TblGrid(self, {self.}Prefix, "tblGrid");
        container_.Set({self.}XmlChildTblGrid);
    end
    return {self.}XmlChildTblGrid and not {self.}XmlChildTblGrid.Removed ? {self.}XmlChildTblGrid : fallback_.XmlChildTblGrid;
end;

function Tbl.WriteXmlChildTblGrid(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTblGrid) then
            {self.}RemoveChild({self.}XmlChildTblGrid);
    end
    else if v is class(TblGrid) then
    begin
        {self.}XmlChildTblGrid := v;
        container_.Set({self.}XmlChildTblGrid);
    end
    else begin
        raise "Invalid assignment: TblGrid expects TblGrid or nil";
    end
end;

function Tbl.ReadTrs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "tr", ind);
end;

function Tbl.WriteTrs(_index: integer; _value: nil_OR_Tr);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadTrs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "tr", ind, _value) then
            raise format("Index out of range: Trs[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Trs expects nil or Tr";
    end
end;

function Tbl.ReadSdts(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "sdt", ind);
end;

function Tbl.WriteSdts(_index: integer; _value: nil_OR_Sdt);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadSdts(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "sdt", ind, _value) then
            raise format("Index out of range: Sdts[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Sdts expects nil or Sdt";
    end
end;

function Tbl.AddTr(): Tr;
begin
    obj := new Tr(self, {self.}Prefix, "tr");
    container_.Insert(obj);
    return obj;
end;

function Tbl.AddSdt(): Sdt;
begin
    obj := new Sdt(self, {self.}Prefix, "sdt");
    container_.Insert(obj);
    return obj;
end;

function Tbl.AppendTr(): Tr;
begin
    obj := new Tr(self, {self.}Prefix, "tr");
    container_.Append(obj);
    return obj;
end;

function Tbl.AppendSdt(): Sdt;
begin
    obj := new Sdt(self, {self.}Prefix, "sdt");
    container_.Append(obj);
    return obj;
end;

function TblPr.Create();overload;
begin
    {self.}Create(nil, "w", "tblPr");
end;

function TblPr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TblPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TblPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "jc": array(0, makeweakref(thisFunction(ReadXmlChildJc))),
        pre + "shd": array(1, makeweakref(thisFunction(ReadXmlChildShd))),
        pre + "tblStyle": array(2, makeweakref(thisFunction(ReadXmlChildTblStyle))),
        pre + "tblW": array(3, makeweakref(thisFunction(ReadXmlChildTblW))),
        pre + "tblInd": array(4, makeweakref(thisFunction(ReadXmlChildTblInd))),
        pre + "tblLayout": array(5, makeweakref(thisFunction(ReadXmlChildTblLayout))),
        pre + "tblLook": array(6, makeweakref(thisFunction(ReadXmlChildTblLook))),
        pre + "tblBorders": array(7, makeweakref(thisFunction(ReadXmlChildTblBorders))),
        pre + "tblCellMar": array(8, makeweakref(thisFunction(ReadXmlChildTblCellMar))),
        pre + "tblCellSpacing": array(9, makeweakref(thisFunction(ReadXmlChildTblCellSpacing))),
        pre + "tblCaption": array(10, makeweakref(thisFunction(ReadXmlChildTblCaption))),
        pre + "tblDescription": array(11, makeweakref(thisFunction(ReadXmlChildTblDescription))),
        pre + "tblStyleRowBandSize": array(12, makeweakref(thisFunction(ReadXmlChildTblStyleRowBandSize))),
        pre + "tblStyleColBandSize": array(13, makeweakref(thisFunction(ReadXmlChildTblStyleColBandSize))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TblPr.Copy(_obj: TblPr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildJc) then
        {self.}Jc.Copy(_obj.XmlChildJc);
    if not ifnil(_obj.XmlChildShd) then
        {self.}Shd.Copy(_obj.XmlChildShd);
    if not ifnil(_obj.XmlChildTblStyle) then
        {self.}TblStyle.Copy(_obj.XmlChildTblStyle);
    if not ifnil(_obj.XmlChildTblW) then
        {self.}TblW.Copy(_obj.XmlChildTblW);
    if not ifnil(_obj.XmlChildTblInd) then
        {self.}TblInd.Copy(_obj.XmlChildTblInd);
    if not ifnil(_obj.XmlChildTblLayout) then
        {self.}TblLayout.Copy(_obj.XmlChildTblLayout);
    if not ifnil(_obj.XmlChildTblLook) then
        {self.}TblLook.Copy(_obj.XmlChildTblLook);
    if not ifnil(_obj.XmlChildTblBorders) then
        {self.}TblBorders.Copy(_obj.XmlChildTblBorders);
    if not ifnil(_obj.XmlChildTblCellMar) then
        {self.}TblCellMar.Copy(_obj.XmlChildTblCellMar);
    if not ifnil(_obj.XmlChildTblCellSpacing) then
        {self.}TblCellSpacing.Copy(_obj.XmlChildTblCellSpacing);
    if not ifnil(_obj.XmlChildTblCaption) then
        {self.}TblCaption.Copy(_obj.XmlChildTblCaption);
    if not ifnil(_obj.XmlChildTblDescription) then
        {self.}TblDescription.Copy(_obj.XmlChildTblDescription);
    if not ifnil(_obj.XmlChildTblStyleRowBandSize) then
        {self.}TblStyleRowBandSize.Copy(_obj.XmlChildTblStyleRowBandSize);
    if not ifnil(_obj.XmlChildTblStyleColBandSize) then
        {self.}TblStyleColBandSize.Copy(_obj.XmlChildTblStyleColBandSize);
    tslassigning := tslassigning_backup;
end;

function TblPr.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildJc) then
        {self.}XmlChildJc.ConvertToPoint();
    if not ifnil({self.}XmlChildShd) then
        {self.}XmlChildShd.ConvertToPoint();
    if not ifnil({self.}XmlChildTblStyle) then
        {self.}XmlChildTblStyle.ConvertToPoint();
    if not ifnil({self.}XmlChildTblW) then
        {self.}XmlChildTblW.ConvertToPoint();
    if not ifnil({self.}XmlChildTblInd) then
        {self.}XmlChildTblInd.ConvertToPoint();
    if not ifnil({self.}XmlChildTblLayout) then
        {self.}XmlChildTblLayout.ConvertToPoint();
    if not ifnil({self.}XmlChildTblLook) then
        {self.}XmlChildTblLook.ConvertToPoint();
    if not ifnil({self.}XmlChildTblBorders) then
        {self.}XmlChildTblBorders.ConvertToPoint();
    if not ifnil({self.}XmlChildTblCellMar) then
        {self.}XmlChildTblCellMar.ConvertToPoint();
    if not ifnil({self.}XmlChildTblCellSpacing) then
        {self.}XmlChildTblCellSpacing.ConvertToPoint();
    if not ifnil({self.}XmlChildTblCaption) then
        {self.}XmlChildTblCaption.ConvertToPoint();
    if not ifnil({self.}XmlChildTblDescription) then
        {self.}XmlChildTblDescription.ConvertToPoint();
    if not ifnil({self.}XmlChildTblStyleRowBandSize) then
        {self.}XmlChildTblStyleRowBandSize.ConvertToPoint();
    if not ifnil({self.}XmlChildTblStyleColBandSize) then
        {self.}XmlChildTblStyleColBandSize.ConvertToPoint();
end;

function TblPr.ReadXmlChildJc(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildJc) or {self.}XmlChildJc.Removed) then
    begin
        {self.}XmlChildJc := new PureWVal(self, {self.}Prefix, "jc");
        container_.Set({self.}XmlChildJc);
    end
    return {self.}XmlChildJc and not {self.}XmlChildJc.Removed ? {self.}XmlChildJc : fallback_.XmlChildJc;
end;

function TblPr.WriteXmlChildJc(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildJc) then
            {self.}RemoveChild({self.}XmlChildJc);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildJc := v;
        container_.Set({self.}XmlChildJc);
    end
    else begin
        raise "Invalid assignment: Jc expects PureWVal or nil";
    end
end;

function TblPr.ReadXmlChildShd(): Shd;
begin
    if tslassigning and (ifnil({self.}XmlChildShd) or {self.}XmlChildShd.Removed) then
    begin
        {self.}XmlChildShd := new Shd(self, {self.}Prefix, "shd");
        container_.Set({self.}XmlChildShd);
    end
    return {self.}XmlChildShd and not {self.}XmlChildShd.Removed ? {self.}XmlChildShd : fallback_.XmlChildShd;
end;

function TblPr.WriteXmlChildShd(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildShd) then
            {self.}RemoveChild({self.}XmlChildShd);
    end
    else if v is class(Shd) then
    begin
        {self.}XmlChildShd := v;
        container_.Set({self.}XmlChildShd);
    end
    else begin
        raise "Invalid assignment: Shd expects Shd or nil";
    end
end;

function TblPr.ReadXmlChildTblStyle(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildTblStyle) or {self.}XmlChildTblStyle.Removed) then
    begin
        {self.}XmlChildTblStyle := new PureWVal(self, {self.}Prefix, "tblStyle");
        container_.Set({self.}XmlChildTblStyle);
    end
    return {self.}XmlChildTblStyle and not {self.}XmlChildTblStyle.Removed ? {self.}XmlChildTblStyle : fallback_.XmlChildTblStyle;
end;

function TblPr.WriteXmlChildTblStyle(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTblStyle) then
            {self.}RemoveChild({self.}XmlChildTblStyle);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildTblStyle := v;
        container_.Set({self.}XmlChildTblStyle);
    end
    else begin
        raise "Invalid assignment: TblStyle expects PureWVal or nil";
    end
end;

function TblPr.ReadXmlChildTblW(): TblW;
begin
    if tslassigning and (ifnil({self.}XmlChildTblW) or {self.}XmlChildTblW.Removed) then
    begin
        {self.}XmlChildTblW := new TblW(self, {self.}Prefix, "tblW");
        container_.Set({self.}XmlChildTblW);
    end
    return {self.}XmlChildTblW and not {self.}XmlChildTblW.Removed ? {self.}XmlChildTblW : fallback_.XmlChildTblW;
end;

function TblPr.WriteXmlChildTblW(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTblW) then
            {self.}RemoveChild({self.}XmlChildTblW);
    end
    else if v is class(TblW) then
    begin
        {self.}XmlChildTblW := v;
        container_.Set({self.}XmlChildTblW);
    end
    else begin
        raise "Invalid assignment: TblW expects TblW or nil";
    end
end;

function TblPr.ReadXmlChildTblInd(): TblW;
begin
    if tslassigning and (ifnil({self.}XmlChildTblInd) or {self.}XmlChildTblInd.Removed) then
    begin
        {self.}XmlChildTblInd := new TblW(self, {self.}Prefix, "tblInd");
        container_.Set({self.}XmlChildTblInd);
    end
    return {self.}XmlChildTblInd and not {self.}XmlChildTblInd.Removed ? {self.}XmlChildTblInd : fallback_.XmlChildTblInd;
end;

function TblPr.WriteXmlChildTblInd(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTblInd) then
            {self.}RemoveChild({self.}XmlChildTblInd);
    end
    else if v is class(TblW) then
    begin
        {self.}XmlChildTblInd := v;
        container_.Set({self.}XmlChildTblInd);
    end
    else begin
        raise "Invalid assignment: TblInd expects TblW or nil";
    end
end;

function TblPr.ReadXmlChildTblLayout(): TblLayout;
begin
    if tslassigning and (ifnil({self.}XmlChildTblLayout) or {self.}XmlChildTblLayout.Removed) then
    begin
        {self.}XmlChildTblLayout := new TblLayout(self, {self.}Prefix, "tblLayout");
        container_.Set({self.}XmlChildTblLayout);
    end
    return {self.}XmlChildTblLayout and not {self.}XmlChildTblLayout.Removed ? {self.}XmlChildTblLayout : fallback_.XmlChildTblLayout;
end;

function TblPr.WriteXmlChildTblLayout(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTblLayout) then
            {self.}RemoveChild({self.}XmlChildTblLayout);
    end
    else if v is class(TblLayout) then
    begin
        {self.}XmlChildTblLayout := v;
        container_.Set({self.}XmlChildTblLayout);
    end
    else begin
        raise "Invalid assignment: TblLayout expects TblLayout or nil";
    end
end;

function TblPr.ReadXmlChildTblLook(): TblLook;
begin
    if tslassigning and (ifnil({self.}XmlChildTblLook) or {self.}XmlChildTblLook.Removed) then
    begin
        {self.}XmlChildTblLook := new TblLook(self, {self.}Prefix, "tblLook");
        container_.Set({self.}XmlChildTblLook);
    end
    return {self.}XmlChildTblLook and not {self.}XmlChildTblLook.Removed ? {self.}XmlChildTblLook : fallback_.XmlChildTblLook;
end;

function TblPr.WriteXmlChildTblLook(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTblLook) then
            {self.}RemoveChild({self.}XmlChildTblLook);
    end
    else if v is class(TblLook) then
    begin
        {self.}XmlChildTblLook := v;
        container_.Set({self.}XmlChildTblLook);
    end
    else begin
        raise "Invalid assignment: TblLook expects TblLook or nil";
    end
end;

function TblPr.ReadXmlChildTblBorders(): TblBorders;
begin
    if tslassigning and (ifnil({self.}XmlChildTblBorders) or {self.}XmlChildTblBorders.Removed) then
    begin
        {self.}XmlChildTblBorders := new TblBorders(self, {self.}Prefix, "tblBorders");
        container_.Set({self.}XmlChildTblBorders);
    end
    return {self.}XmlChildTblBorders and not {self.}XmlChildTblBorders.Removed ? {self.}XmlChildTblBorders : fallback_.XmlChildTblBorders;
end;

function TblPr.WriteXmlChildTblBorders(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTblBorders) then
            {self.}RemoveChild({self.}XmlChildTblBorders);
    end
    else if v is class(TblBorders) then
    begin
        {self.}XmlChildTblBorders := v;
        container_.Set({self.}XmlChildTblBorders);
    end
    else begin
        raise "Invalid assignment: TblBorders expects TblBorders or nil";
    end
end;

function TblPr.ReadXmlChildTblCellMar(): TblCellMar;
begin
    if tslassigning and (ifnil({self.}XmlChildTblCellMar) or {self.}XmlChildTblCellMar.Removed) then
    begin
        {self.}XmlChildTblCellMar := new TblCellMar(self, {self.}Prefix, "tblCellMar");
        container_.Set({self.}XmlChildTblCellMar);
    end
    return {self.}XmlChildTblCellMar and not {self.}XmlChildTblCellMar.Removed ? {self.}XmlChildTblCellMar : fallback_.XmlChildTblCellMar;
end;

function TblPr.WriteXmlChildTblCellMar(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTblCellMar) then
            {self.}RemoveChild({self.}XmlChildTblCellMar);
    end
    else if v is class(TblCellMar) then
    begin
        {self.}XmlChildTblCellMar := v;
        container_.Set({self.}XmlChildTblCellMar);
    end
    else begin
        raise "Invalid assignment: TblCellMar expects TblCellMar or nil";
    end
end;

function TblPr.ReadXmlChildTblCellSpacing(): TblCellSpacing;
begin
    if tslassigning and (ifnil({self.}XmlChildTblCellSpacing) or {self.}XmlChildTblCellSpacing.Removed) then
    begin
        {self.}XmlChildTblCellSpacing := new TblCellSpacing(self, {self.}Prefix, "tblCellSpacing");
        container_.Set({self.}XmlChildTblCellSpacing);
    end
    return {self.}XmlChildTblCellSpacing and not {self.}XmlChildTblCellSpacing.Removed ? {self.}XmlChildTblCellSpacing : fallback_.XmlChildTblCellSpacing;
end;

function TblPr.WriteXmlChildTblCellSpacing(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTblCellSpacing) then
            {self.}RemoveChild({self.}XmlChildTblCellSpacing);
    end
    else if v is class(TblCellSpacing) then
    begin
        {self.}XmlChildTblCellSpacing := v;
        container_.Set({self.}XmlChildTblCellSpacing);
    end
    else begin
        raise "Invalid assignment: TblCellSpacing expects TblCellSpacing or nil";
    end
end;

function TblPr.ReadXmlChildTblCaption(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildTblCaption) or {self.}XmlChildTblCaption.Removed) then
    begin
        {self.}XmlChildTblCaption := new PureWVal(self, {self.}Prefix, "tblCaption");
        container_.Set({self.}XmlChildTblCaption);
    end
    return {self.}XmlChildTblCaption and not {self.}XmlChildTblCaption.Removed ? {self.}XmlChildTblCaption : fallback_.XmlChildTblCaption;
end;

function TblPr.WriteXmlChildTblCaption(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTblCaption) then
            {self.}RemoveChild({self.}XmlChildTblCaption);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildTblCaption := v;
        container_.Set({self.}XmlChildTblCaption);
    end
    else begin
        raise "Invalid assignment: TblCaption expects PureWVal or nil";
    end
end;

function TblPr.ReadXmlChildTblDescription(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildTblDescription) or {self.}XmlChildTblDescription.Removed) then
    begin
        {self.}XmlChildTblDescription := new PureWVal(self, {self.}Prefix, "tblDescription");
        container_.Set({self.}XmlChildTblDescription);
    end
    return {self.}XmlChildTblDescription and not {self.}XmlChildTblDescription.Removed ? {self.}XmlChildTblDescription : fallback_.XmlChildTblDescription;
end;

function TblPr.WriteXmlChildTblDescription(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTblDescription) then
            {self.}RemoveChild({self.}XmlChildTblDescription);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildTblDescription := v;
        container_.Set({self.}XmlChildTblDescription);
    end
    else begin
        raise "Invalid assignment: TblDescription expects PureWVal or nil";
    end
end;

function TblPr.ReadXmlChildTblStyleRowBandSize(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildTblStyleRowBandSize) or {self.}XmlChildTblStyleRowBandSize.Removed) then
    begin
        {self.}XmlChildTblStyleRowBandSize := new PureWVal(self, {self.}Prefix, "tblStyleRowBandSize");
        container_.Set({self.}XmlChildTblStyleRowBandSize);
    end
    return {self.}XmlChildTblStyleRowBandSize and not {self.}XmlChildTblStyleRowBandSize.Removed ? {self.}XmlChildTblStyleRowBandSize : fallback_.XmlChildTblStyleRowBandSize;
end;

function TblPr.WriteXmlChildTblStyleRowBandSize(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTblStyleRowBandSize) then
            {self.}RemoveChild({self.}XmlChildTblStyleRowBandSize);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildTblStyleRowBandSize := v;
        container_.Set({self.}XmlChildTblStyleRowBandSize);
    end
    else begin
        raise "Invalid assignment: TblStyleRowBandSize expects PureWVal or nil";
    end
end;

function TblPr.ReadXmlChildTblStyleColBandSize(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildTblStyleColBandSize) or {self.}XmlChildTblStyleColBandSize.Removed) then
    begin
        {self.}XmlChildTblStyleColBandSize := new PureWVal(self, {self.}Prefix, "tblStyleColBandSize");
        container_.Set({self.}XmlChildTblStyleColBandSize);
    end
    return {self.}XmlChildTblStyleColBandSize and not {self.}XmlChildTblStyleColBandSize.Removed ? {self.}XmlChildTblStyleColBandSize : fallback_.XmlChildTblStyleColBandSize;
end;

function TblPr.WriteXmlChildTblStyleColBandSize(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTblStyleColBandSize) then
            {self.}RemoveChild({self.}XmlChildTblStyleColBandSize);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildTblStyleColBandSize := v;
        container_.Set({self.}XmlChildTblStyleColBandSize);
    end
    else begin
        raise "Invalid assignment: TblStyleColBandSize expects PureWVal or nil";
    end
end;

function TblCellSpacing.Create();overload;
begin
    {self.}Create(nil, "w", "tblCellSpacing");
end;

function TblCellSpacing.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TblCellSpacing.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TblCellSpacing.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "w": makeweakref(thisFunction(WriteXmlAttrW)),
        pre + "type": makeweakref(thisFunction(WriteXmlAttrType)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TblCellSpacing.Copy(_obj: TblCellSpacing);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.W) then
        {self.}W := _obj.W;
    if not ifnil(_obj.Type) then
        {self.}Type := _obj.Type;
    tslassigning := tslassigning_backup;
end;

function TblCellSpacing.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrW) then
        {self.}W := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrW.Value);
end;

function TblCellSpacing.ReadXmlAttrW();
begin
    return ifnil({self.}XmlAttrW.Value) ? fallback_.XmlAttrW.Value : {self.}XmlAttrW.Value;
end;

function TblCellSpacing.WriteXmlAttrW(_value: any);
begin
    if ifnil({self.}XmlAttrW) then
    begin
        {self.}XmlAttrW := new OpenXmlAttribute({self.}Prefix, "w", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "w" : "w"] := {self.}XmlAttrW;
    end
    {self.}XmlAttrW.Value := _value;
end;

function TblCellSpacing.ReadXmlAttrType();
begin
    return ifnil({self.}XmlAttrType.Value) ? fallback_.XmlAttrType.Value : {self.}XmlAttrType.Value;
end;

function TblCellSpacing.WriteXmlAttrType(_value: any);
begin
    if ifnil({self.}XmlAttrType) then
    begin
        {self.}XmlAttrType := new OpenXmlAttribute({self.}Prefix, "type", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "type" : "type"] := {self.}XmlAttrType;
    end
    {self.}XmlAttrType.Value := _value;
end;

function TblW.Create();overload;
begin
    {self.}Create(nil, "w", "tblW");
end;

function TblW.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TblW.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TblW.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "w": makeweakref(thisFunction(WriteXmlAttrW)),
        pre + "type": makeweakref(thisFunction(WriteXmlAttrType)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TblW.Copy(_obj: TblW);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.W) then
        {self.}W := _obj.W;
    if not ifnil(_obj.Type) then
        {self.}Type := _obj.Type;
    tslassigning := tslassigning_backup;
end;

function TblW.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrW) then
        {self.}W := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrW.Value);
end;

function TblW.ReadXmlAttrW();
begin
    return ifnil({self.}XmlAttrW.Value) ? fallback_.XmlAttrW.Value : {self.}XmlAttrW.Value;
end;

function TblW.WriteXmlAttrW(_value: any);
begin
    if ifnil({self.}XmlAttrW) then
    begin
        {self.}XmlAttrW := new OpenXmlAttribute({self.}Prefix, "w", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "w" : "w"] := {self.}XmlAttrW;
    end
    {self.}XmlAttrW.Value := _value;
end;

function TblW.ReadXmlAttrType();
begin
    return ifnil({self.}XmlAttrType.Value) ? fallback_.XmlAttrType.Value : {self.}XmlAttrType.Value;
end;

function TblW.WriteXmlAttrType(_value: any);
begin
    if ifnil({self.}XmlAttrType) then
    begin
        {self.}XmlAttrType := new OpenXmlAttribute({self.}Prefix, "type", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "type" : "type"] := {self.}XmlAttrType;
    end
    {self.}XmlAttrType.Value := _value;
end;

function TblLayout.Create();overload;
begin
    {self.}Create(nil, "w", "tblLayout");
end;

function TblLayout.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TblLayout.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TblLayout.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "type": makeweakref(thisFunction(WriteXmlAttrType)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TblLayout.Copy(_obj: TblLayout);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Type) then
        {self.}Type := _obj.Type;
    tslassigning := tslassigning_backup;
end;

function TblLayout.ConvertToPoint();override;
begin

end;

function TblLayout.ReadXmlAttrType();
begin
    return ifnil({self.}XmlAttrType.Value) ? fallback_.XmlAttrType.Value : {self.}XmlAttrType.Value;
end;

function TblLayout.WriteXmlAttrType(_value: any);
begin
    if ifnil({self.}XmlAttrType) then
    begin
        {self.}XmlAttrType := new OpenXmlAttribute({self.}Prefix, "type", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "type" : "type"] := {self.}XmlAttrType;
    end
    {self.}XmlAttrType.Value := _value;
end;

function TblLook.Create();overload;
begin
    {self.}Create(nil, "w", "tblLook");
end;

function TblLook.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TblLook.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TblLook.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "val": makeweakref(thisFunction(WriteXmlAttrVal)),
        pre + "firstRow": makeweakref(thisFunction(WriteXmlAttrFirstRow)),
        pre + "lastRow": makeweakref(thisFunction(WriteXmlAttrLastRow)),
        pre + "firstColumn": makeweakref(thisFunction(WriteXmlAttrFirstColumn)),
        pre + "lastColumn": makeweakref(thisFunction(WriteXmlAttrLastColumn)),
        pre + "noHBand": makeweakref(thisFunction(WriteXmlAttrNoHBand)),
        pre + "noVBand": makeweakref(thisFunction(WriteXmlAttrNoVBand)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TblLook.Copy(_obj: TblLook);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    if not ifnil(_obj.FirstRow) then
        {self.}FirstRow := _obj.FirstRow;
    if not ifnil(_obj.LastRow) then
        {self.}LastRow := _obj.LastRow;
    if not ifnil(_obj.FirstColumn) then
        {self.}FirstColumn := _obj.FirstColumn;
    if not ifnil(_obj.LastColumn) then
        {self.}LastColumn := _obj.LastColumn;
    if not ifnil(_obj.NoHBand) then
        {self.}NoHBand := _obj.NoHBand;
    if not ifnil(_obj.NoVBand) then
        {self.}NoVBand := _obj.NoVBand;
    tslassigning := tslassigning_backup;
end;

function TblLook.ConvertToPoint();override;
begin

end;

function TblLook.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function TblLook.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute({self.}Prefix, "val", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "val" : "val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function TblLook.ReadXmlAttrFirstRow();
begin
    return ifnil({self.}XmlAttrFirstRow.Value) ? fallback_.XmlAttrFirstRow.Value : {self.}XmlAttrFirstRow.Value;
end;

function TblLook.WriteXmlAttrFirstRow(_value: any);
begin
    if ifnil({self.}XmlAttrFirstRow) then
    begin
        {self.}XmlAttrFirstRow := new OpenXmlAttribute({self.}Prefix, "firstRow", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "firstRow" : "firstRow"] := {self.}XmlAttrFirstRow;
    end
    {self.}XmlAttrFirstRow.Value := _value;
end;

function TblLook.ReadXmlAttrLastRow();
begin
    return ifnil({self.}XmlAttrLastRow.Value) ? fallback_.XmlAttrLastRow.Value : {self.}XmlAttrLastRow.Value;
end;

function TblLook.WriteXmlAttrLastRow(_value: any);
begin
    if ifnil({self.}XmlAttrLastRow) then
    begin
        {self.}XmlAttrLastRow := new OpenXmlAttribute({self.}Prefix, "lastRow", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "lastRow" : "lastRow"] := {self.}XmlAttrLastRow;
    end
    {self.}XmlAttrLastRow.Value := _value;
end;

function TblLook.ReadXmlAttrFirstColumn();
begin
    return ifnil({self.}XmlAttrFirstColumn.Value) ? fallback_.XmlAttrFirstColumn.Value : {self.}XmlAttrFirstColumn.Value;
end;

function TblLook.WriteXmlAttrFirstColumn(_value: any);
begin
    if ifnil({self.}XmlAttrFirstColumn) then
    begin
        {self.}XmlAttrFirstColumn := new OpenXmlAttribute({self.}Prefix, "firstColumn", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "firstColumn" : "firstColumn"] := {self.}XmlAttrFirstColumn;
    end
    {self.}XmlAttrFirstColumn.Value := _value;
end;

function TblLook.ReadXmlAttrLastColumn();
begin
    return ifnil({self.}XmlAttrLastColumn.Value) ? fallback_.XmlAttrLastColumn.Value : {self.}XmlAttrLastColumn.Value;
end;

function TblLook.WriteXmlAttrLastColumn(_value: any);
begin
    if ifnil({self.}XmlAttrLastColumn) then
    begin
        {self.}XmlAttrLastColumn := new OpenXmlAttribute({self.}Prefix, "lastColumn", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "lastColumn" : "lastColumn"] := {self.}XmlAttrLastColumn;
    end
    {self.}XmlAttrLastColumn.Value := _value;
end;

function TblLook.ReadXmlAttrNoHBand();
begin
    return ifnil({self.}XmlAttrNoHBand.Value) ? fallback_.XmlAttrNoHBand.Value : {self.}XmlAttrNoHBand.Value;
end;

function TblLook.WriteXmlAttrNoHBand(_value: any);
begin
    if ifnil({self.}XmlAttrNoHBand) then
    begin
        {self.}XmlAttrNoHBand := new OpenXmlAttribute({self.}Prefix, "noHBand", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "noHBand" : "noHBand"] := {self.}XmlAttrNoHBand;
    end
    {self.}XmlAttrNoHBand.Value := _value;
end;

function TblLook.ReadXmlAttrNoVBand();
begin
    return ifnil({self.}XmlAttrNoVBand.Value) ? fallback_.XmlAttrNoVBand.Value : {self.}XmlAttrNoVBand.Value;
end;

function TblLook.WriteXmlAttrNoVBand(_value: any);
begin
    if ifnil({self.}XmlAttrNoVBand) then
    begin
        {self.}XmlAttrNoVBand := new OpenXmlAttribute({self.}Prefix, "noVBand", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "noVBand" : "noVBand"] := {self.}XmlAttrNoVBand;
    end
    {self.}XmlAttrNoVBand.Value := _value;
end;

function TblBorders.Create();overload;
begin
    {self.}Create(nil, "w", "tblBorders");
end;

function TblBorders.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TblBorders.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TblBorders.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "top": array(0, makeweakref(thisFunction(ReadXmlChildTop))),
        pre + "left": array(1, makeweakref(thisFunction(ReadXmlChildLeft))),
        pre + "bottom": array(2, makeweakref(thisFunction(ReadXmlChildBottom))),
        pre + "right": array(3, makeweakref(thisFunction(ReadXmlChildRight))),
        pre + "insideH": array(4, makeweakref(thisFunction(ReadXmlChildInsideH))),
        pre + "insideV": array(5, makeweakref(thisFunction(ReadXmlChildInsideV))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TblBorders.Copy(_obj: TblBorders);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildTop) then
        {self.}Top.Copy(_obj.XmlChildTop);
    if not ifnil(_obj.XmlChildLeft) then
        {self.}Left.Copy(_obj.XmlChildLeft);
    if not ifnil(_obj.XmlChildBottom) then
        {self.}Bottom.Copy(_obj.XmlChildBottom);
    if not ifnil(_obj.XmlChildRight) then
        {self.}Right.Copy(_obj.XmlChildRight);
    if not ifnil(_obj.XmlChildInsideH) then
        {self.}InsideH.Copy(_obj.XmlChildInsideH);
    if not ifnil(_obj.XmlChildInsideV) then
        {self.}InsideV.Copy(_obj.XmlChildInsideV);
    tslassigning := tslassigning_backup;
end;

function TblBorders.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildTop) then
        {self.}XmlChildTop.ConvertToPoint();
    if not ifnil({self.}XmlChildLeft) then
        {self.}XmlChildLeft.ConvertToPoint();
    if not ifnil({self.}XmlChildBottom) then
        {self.}XmlChildBottom.ConvertToPoint();
    if not ifnil({self.}XmlChildRight) then
        {self.}XmlChildRight.ConvertToPoint();
    if not ifnil({self.}XmlChildInsideH) then
        {self.}XmlChildInsideH.ConvertToPoint();
    if not ifnil({self.}XmlChildInsideV) then
        {self.}XmlChildInsideV.ConvertToPoint();
end;

function TblBorders.ReadXmlChildTop(): TblBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildTop) or {self.}XmlChildTop.Removed) then
    begin
        {self.}XmlChildTop := new TblBorder(self, {self.}Prefix, "top");
        container_.Set({self.}XmlChildTop);
    end
    return {self.}XmlChildTop and not {self.}XmlChildTop.Removed ? {self.}XmlChildTop : fallback_.XmlChildTop;
end;

function TblBorders.WriteXmlChildTop(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTop) then
            {self.}RemoveChild({self.}XmlChildTop);
    end
    else if v is class(TblBorder) then
    begin
        {self.}XmlChildTop := v;
        container_.Set({self.}XmlChildTop);
    end
    else begin
        raise "Invalid assignment: Top expects TblBorder or nil";
    end
end;

function TblBorders.ReadXmlChildLeft(): TblBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildLeft) or {self.}XmlChildLeft.Removed) then
    begin
        {self.}XmlChildLeft := new TblBorder(self, {self.}Prefix, "left");
        container_.Set({self.}XmlChildLeft);
    end
    return {self.}XmlChildLeft and not {self.}XmlChildLeft.Removed ? {self.}XmlChildLeft : fallback_.XmlChildLeft;
end;

function TblBorders.WriteXmlChildLeft(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildLeft) then
            {self.}RemoveChild({self.}XmlChildLeft);
    end
    else if v is class(TblBorder) then
    begin
        {self.}XmlChildLeft := v;
        container_.Set({self.}XmlChildLeft);
    end
    else begin
        raise "Invalid assignment: Left expects TblBorder or nil";
    end
end;

function TblBorders.ReadXmlChildBottom(): TblBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildBottom) or {self.}XmlChildBottom.Removed) then
    begin
        {self.}XmlChildBottom := new TblBorder(self, {self.}Prefix, "bottom");
        container_.Set({self.}XmlChildBottom);
    end
    return {self.}XmlChildBottom and not {self.}XmlChildBottom.Removed ? {self.}XmlChildBottom : fallback_.XmlChildBottom;
end;

function TblBorders.WriteXmlChildBottom(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildBottom) then
            {self.}RemoveChild({self.}XmlChildBottom);
    end
    else if v is class(TblBorder) then
    begin
        {self.}XmlChildBottom := v;
        container_.Set({self.}XmlChildBottom);
    end
    else begin
        raise "Invalid assignment: Bottom expects TblBorder or nil";
    end
end;

function TblBorders.ReadXmlChildRight(): TblBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildRight) or {self.}XmlChildRight.Removed) then
    begin
        {self.}XmlChildRight := new TblBorder(self, {self.}Prefix, "right");
        container_.Set({self.}XmlChildRight);
    end
    return {self.}XmlChildRight and not {self.}XmlChildRight.Removed ? {self.}XmlChildRight : fallback_.XmlChildRight;
end;

function TblBorders.WriteXmlChildRight(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRight) then
            {self.}RemoveChild({self.}XmlChildRight);
    end
    else if v is class(TblBorder) then
    begin
        {self.}XmlChildRight := v;
        container_.Set({self.}XmlChildRight);
    end
    else begin
        raise "Invalid assignment: Right expects TblBorder or nil";
    end
end;

function TblBorders.ReadXmlChildInsideH(): TblBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildInsideH) or {self.}XmlChildInsideH.Removed) then
    begin
        {self.}XmlChildInsideH := new TblBorder(self, {self.}Prefix, "insideH");
        container_.Set({self.}XmlChildInsideH);
    end
    return {self.}XmlChildInsideH and not {self.}XmlChildInsideH.Removed ? {self.}XmlChildInsideH : fallback_.XmlChildInsideH;
end;

function TblBorders.WriteXmlChildInsideH(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildInsideH) then
            {self.}RemoveChild({self.}XmlChildInsideH);
    end
    else if v is class(TblBorder) then
    begin
        {self.}XmlChildInsideH := v;
        container_.Set({self.}XmlChildInsideH);
    end
    else begin
        raise "Invalid assignment: InsideH expects TblBorder or nil";
    end
end;

function TblBorders.ReadXmlChildInsideV(): TblBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildInsideV) or {self.}XmlChildInsideV.Removed) then
    begin
        {self.}XmlChildInsideV := new TblBorder(self, {self.}Prefix, "insideV");
        container_.Set({self.}XmlChildInsideV);
    end
    return {self.}XmlChildInsideV and not {self.}XmlChildInsideV.Removed ? {self.}XmlChildInsideV : fallback_.XmlChildInsideV;
end;

function TblBorders.WriteXmlChildInsideV(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildInsideV) then
            {self.}RemoveChild({self.}XmlChildInsideV);
    end
    else if v is class(TblBorder) then
    begin
        {self.}XmlChildInsideV := v;
        container_.Set({self.}XmlChildInsideV);
    end
    else begin
        raise "Invalid assignment: InsideV expects TblBorder or nil";
    end
end;

function TblBorder.Create();overload;
begin
    {self.}Create(nil, "w", "");
end;

function TblBorder.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TblBorder.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TblBorder.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "val": makeweakref(thisFunction(WriteXmlAttrVal)),
        pre + "color": makeweakref(thisFunction(WriteXmlAttrColor)),
        pre + "space": makeweakref(thisFunction(WriteXmlAttrSpace)),
        pre + "themeColor": makeweakref(thisFunction(WriteXmlAttrThemeColor)),
        pre + "themeTint": makeweakref(thisFunction(WriteXmlAttrThemeTint)),
        pre + "sz": makeweakref(thisFunction(WriteXmlAttrSz)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TblBorder.Copy(_obj: TblBorder);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    if not ifnil(_obj.Color) then
        {self.}Color := _obj.Color;
    if not ifnil(_obj.Space) then
        {self.}Space := _obj.Space;
    if not ifnil(_obj.ThemeColor) then
        {self.}ThemeColor := _obj.ThemeColor;
    if not ifnil(_obj.ThemeTint) then
        {self.}ThemeTint := _obj.ThemeTint;
    if not ifnil(_obj.Sz) then
        {self.}Sz := _obj.Sz;
    tslassigning := tslassigning_backup;
end;

function TblBorder.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrSz) then
        {self.}Sz := TSSafeUnitConverter.EighthPointToPoints({self.}XmlAttrSz.Value);
end;

function TblBorder.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function TblBorder.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute({self.}Prefix, "val", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "val" : "val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function TblBorder.ReadXmlAttrColor();
begin
    return ifnil({self.}XmlAttrColor.Value) ? fallback_.XmlAttrColor.Value : {self.}XmlAttrColor.Value;
end;

function TblBorder.WriteXmlAttrColor(_value: any);
begin
    if ifnil({self.}XmlAttrColor) then
    begin
        {self.}XmlAttrColor := new OpenXmlAttribute({self.}Prefix, "color", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "color" : "color"] := {self.}XmlAttrColor;
    end
    {self.}XmlAttrColor.Value := _value;
end;

function TblBorder.ReadXmlAttrSpace();
begin
    return ifnil({self.}XmlAttrSpace.Value) ? fallback_.XmlAttrSpace.Value : {self.}XmlAttrSpace.Value;
end;

function TblBorder.WriteXmlAttrSpace(_value: any);
begin
    if ifnil({self.}XmlAttrSpace) then
    begin
        {self.}XmlAttrSpace := new OpenXmlAttribute({self.}Prefix, "space", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "space" : "space"] := {self.}XmlAttrSpace;
    end
    {self.}XmlAttrSpace.Value := _value;
end;

function TblBorder.ReadXmlAttrThemeColor();
begin
    return ifnil({self.}XmlAttrThemeColor.Value) ? fallback_.XmlAttrThemeColor.Value : {self.}XmlAttrThemeColor.Value;
end;

function TblBorder.WriteXmlAttrThemeColor(_value: any);
begin
    if ifnil({self.}XmlAttrThemeColor) then
    begin
        {self.}XmlAttrThemeColor := new OpenXmlAttribute({self.}Prefix, "themeColor", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeColor" : "themeColor"] := {self.}XmlAttrThemeColor;
    end
    {self.}XmlAttrThemeColor.Value := _value;
end;

function TblBorder.ReadXmlAttrThemeTint();
begin
    return ifnil({self.}XmlAttrThemeTint.Value) ? fallback_.XmlAttrThemeTint.Value : {self.}XmlAttrThemeTint.Value;
end;

function TblBorder.WriteXmlAttrThemeTint(_value: any);
begin
    if ifnil({self.}XmlAttrThemeTint) then
    begin
        {self.}XmlAttrThemeTint := new OpenXmlAttribute({self.}Prefix, "themeTint", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeTint" : "themeTint"] := {self.}XmlAttrThemeTint;
    end
    {self.}XmlAttrThemeTint.Value := _value;
end;

function TblBorder.ReadXmlAttrSz();
begin
    return ifnil({self.}XmlAttrSz.Value) ? fallback_.XmlAttrSz.Value : {self.}XmlAttrSz.Value;
end;

function TblBorder.WriteXmlAttrSz(_value: any);
begin
    if ifnil({self.}XmlAttrSz) then
    begin
        {self.}XmlAttrSz := new OpenXmlAttribute({self.}Prefix, "sz", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "sz" : "sz"] := {self.}XmlAttrSz;
    end
    {self.}XmlAttrSz.Value := _value;
end;

function TblGrid.Create();overload;
begin
    {self.}Create(nil, "w", "tblGrid");
end;

function TblGrid.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TblGrid.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TblGrid.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "gridCol": array(0, makeweakref(thisFunction(AppendGridCol))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TblGrid.Copy(_obj: TblGrid);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    tslassigning := tslassigning_backup;
end;

function TblGrid.ConvertToPoint();override;
begin
    elems := {self.}GridCols();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function TblGrid.ReadGridCols(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "gridCol", ind);
end;

function TblGrid.WriteGridCols(_index: integer; _value: nil_OR_GridCol);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadGridCols(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "gridCol", ind, _value) then
            raise format("Index out of range: GridCols[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: GridCols expects nil or GridCol";
    end
end;

function TblGrid.AddGridCol(): GridCol;
begin
    obj := new GridCol(self, {self.}Prefix, "gridCol");
    container_.Insert(obj);
    return obj;
end;

function TblGrid.AppendGridCol(): GridCol;
begin
    obj := new GridCol(self, {self.}Prefix, "gridCol");
    container_.Append(obj);
    return obj;
end;

function GridCol.Create();overload;
begin
    {self.}Create(nil, "w", "gridCol");
end;

function GridCol.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function GridCol.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function GridCol.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "w": makeweakref(thisFunction(WriteXmlAttrw)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function GridCol.Copy(_obj: GridCol);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.w) then
        {self.}w := _obj.w;
    tslassigning := tslassigning_backup;
end;

function GridCol.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrw) then
        {self.}w := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrw.Value);
end;

function GridCol.ReadXmlAttrw();
begin
    return ifnil({self.}XmlAttrw.Value) ? fallback_.XmlAttrw.Value : {self.}XmlAttrw.Value;
end;

function GridCol.WriteXmlAttrw(_value: any);
begin
    if ifnil({self.}XmlAttrw) then
    begin
        {self.}XmlAttrw := new OpenXmlAttribute({self.}Prefix, "w", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "w" : "w"] := {self.}XmlAttrw;
    end
    {self.}XmlAttrw.Value := _value;
end;

function Tr.Create();overload;
begin
    {self.}Create(nil, "w", "tr");
end;

function Tr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Tr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Tr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "w:rsidR": makeweakref(thisFunction(WriteXmlAttrRsidR)),
        "w14:paraId": makeweakref(thisFunction(WriteXmlAttrParaId)),
        "w14:textId": makeweakref(thisFunction(WriteXmlAttrTextId)),
        "w:rsidTr": makeweakref(thisFunction(WriteXmlAttrRsidTr)),
    );
    sorted_child_ := array(
        pre + "trPr": array(0, makeweakref(thisFunction(ReadXmlChildTrPr))),
        pre + "sdt": array(1, makeweakref(thisFunction(AppendSdt))),
        pre + "tc": array(2, makeweakref(thisFunction(AppendTc))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Tr.Copy(_obj: Tr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.RsidR) then
        {self.}RsidR := _obj.RsidR;
    if not ifnil(_obj.ParaId) then
        {self.}ParaId := _obj.ParaId;
    if not ifnil(_obj.TextId) then
        {self.}TextId := _obj.TextId;
    if not ifnil(_obj.RsidTr) then
        {self.}RsidTr := _obj.RsidTr;
    if not ifnil(_obj.XmlChildTrPr) then
        {self.}TrPr.Copy(_obj.XmlChildTrPr);
    tslassigning := tslassigning_backup;
end;

function Tr.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildTrPr) then
        {self.}XmlChildTrPr.ConvertToPoint();
    elems := {self.}Sdts();
    for _,elem in elems do
        elem.ConvertToPoint();
    elems := {self.}Tcs();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Tr.ReadXmlAttrRsidR();
begin
    return ifnil({self.}XmlAttrRsidR.Value) ? fallback_.XmlAttrRsidR.Value : {self.}XmlAttrRsidR.Value;
end;

function Tr.WriteXmlAttrRsidR(_value: any);
begin
    if ifnil({self.}XmlAttrRsidR) then
    begin
        {self.}XmlAttrRsidR := new OpenXmlAttribute("w", "rsidR", nil);
        attributes_["w:rsidR"] := {self.}XmlAttrRsidR;
    end
    {self.}XmlAttrRsidR.Value := _value;
end;

function Tr.ReadXmlAttrParaId();
begin
    return ifnil({self.}XmlAttrParaId.Value) ? fallback_.XmlAttrParaId.Value : {self.}XmlAttrParaId.Value;
end;

function Tr.WriteXmlAttrParaId(_value: any);
begin
    if ifnil({self.}XmlAttrParaId) then
    begin
        {self.}XmlAttrParaId := new OpenXmlAttribute("w14", "paraId", nil);
        attributes_["w14:paraId"] := {self.}XmlAttrParaId;
    end
    {self.}XmlAttrParaId.Value := _value;
end;

function Tr.ReadXmlAttrTextId();
begin
    return ifnil({self.}XmlAttrTextId.Value) ? fallback_.XmlAttrTextId.Value : {self.}XmlAttrTextId.Value;
end;

function Tr.WriteXmlAttrTextId(_value: any);
begin
    if ifnil({self.}XmlAttrTextId) then
    begin
        {self.}XmlAttrTextId := new OpenXmlAttribute("w14", "textId", nil);
        attributes_["w14:textId"] := {self.}XmlAttrTextId;
    end
    {self.}XmlAttrTextId.Value := _value;
end;

function Tr.ReadXmlAttrRsidTr();
begin
    return ifnil({self.}XmlAttrRsidTr.Value) ? fallback_.XmlAttrRsidTr.Value : {self.}XmlAttrRsidTr.Value;
end;

function Tr.WriteXmlAttrRsidTr(_value: any);
begin
    if ifnil({self.}XmlAttrRsidTr) then
    begin
        {self.}XmlAttrRsidTr := new OpenXmlAttribute("w", "rsidTr", nil);
        attributes_["w:rsidTr"] := {self.}XmlAttrRsidTr;
    end
    {self.}XmlAttrRsidTr.Value := _value;
end;

function Tr.ReadXmlChildTrPr(): TrPr;
begin
    if tslassigning and (ifnil({self.}XmlChildTrPr) or {self.}XmlChildTrPr.Removed) then
    begin
        {self.}XmlChildTrPr := new TrPr(self, {self.}Prefix, "trPr");
        container_.Set({self.}XmlChildTrPr);
    end
    return {self.}XmlChildTrPr and not {self.}XmlChildTrPr.Removed ? {self.}XmlChildTrPr : fallback_.XmlChildTrPr;
end;

function Tr.WriteXmlChildTrPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTrPr) then
            {self.}RemoveChild({self.}XmlChildTrPr);
    end
    else if v is class(TrPr) then
    begin
        {self.}XmlChildTrPr := v;
        container_.Set({self.}XmlChildTrPr);
    end
    else begin
        raise "Invalid assignment: TrPr expects TrPr or nil";
    end
end;

function Tr.ReadSdts(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "sdt", ind);
end;

function Tr.WriteSdts(_index: integer; _value: nil_OR_Sdt);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadSdts(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "sdt", ind, _value) then
            raise format("Index out of range: Sdts[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Sdts expects nil or Sdt";
    end
end;

function Tr.ReadTcs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "tc", ind);
end;

function Tr.WriteTcs(_index: integer; _value: nil_OR_Tc);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadTcs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "tc", ind, _value) then
            raise format("Index out of range: Tcs[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Tcs expects nil or Tc";
    end
end;

function Tr.AddSdt(): Sdt;
begin
    obj := new Sdt(self, {self.}Prefix, "sdt");
    container_.Insert(obj);
    return obj;
end;

function Tr.AddTc(): Tc;
begin
    obj := new Tc(self, {self.}Prefix, "tc");
    container_.Insert(obj);
    return obj;
end;

function Tr.AppendSdt(): Sdt;
begin
    obj := new Sdt(self, {self.}Prefix, "sdt");
    container_.Append(obj);
    return obj;
end;

function Tr.AppendTc(): Tc;
begin
    obj := new Tc(self, {self.}Prefix, "tc");
    container_.Append(obj);
    return obj;
end;

function TrPr.Create();overload;
begin
    {self.}Create(nil, "w", "trPr");
end;

function TrPr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TrPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TrPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "trHeight": array(0, makeweakref(thisFunction(ReadXmlChildTrHeight))),
        pre + "tblHeader": array(1, makeweakref(thisFunction(ReadXmlChildTblHeader))),
        pre + "jc": array(2, makeweakref(thisFunction(ReadXmlChildJc))),
        pre + "cantSplit": array(3, makeweakref(thisFunction(ReadXmlChildCantSplit))),
        pre + "cnfStyle": array(4, makeweakref(thisFunction(ReadXmlChildCnfStyle))),
        pre + "ins": array(5, makeweakref(thisFunction(ReadXmlChildIns))),
        pre + "del": array(6, makeweakref(thisFunction(ReadXmlChildDel))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TrPr.Copy(_obj: TrPr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildTrHeight) then
        {self.}TrHeight.Copy(_obj.XmlChildTrHeight);
    if not ifnil(_obj.XmlChildTblHeader) then
        ifnil({self.}XmlChildTblHeader) ? {self.}TblHeader.Copy(_obj.XmlChildTblHeader) : {self.}XmlChildTblHeader.Copy(_obj.XmlChildTblHeader);
    if not ifnil(_obj.XmlChildJc) then
        {self.}Jc.Copy(_obj.XmlChildJc);
    if not ifnil(_obj.XmlChildCantSplit) then
        ifnil({self.}XmlChildCantSplit) ? {self.}CantSplit.Copy(_obj.XmlChildCantSplit) : {self.}XmlChildCantSplit.Copy(_obj.XmlChildCantSplit);
    if not ifnil(_obj.XmlChildCnfStyle) then
        {self.}CnfStyle.Copy(_obj.XmlChildCnfStyle);
    if not ifnil(_obj.XmlChildIns) then
        {self.}Ins.Copy(_obj.XmlChildIns);
    if not ifnil(_obj.XmlChildDel) then
        {self.}Del.Copy(_obj.XmlChildDel);
    tslassigning := tslassigning_backup;
end;

function TrPr.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildTrHeight) then
        {self.}XmlChildTrHeight.ConvertToPoint();
    if not ifnil({self.}XmlChildJc) then
        {self.}XmlChildJc.ConvertToPoint();
    if not ifnil({self.}XmlChildCnfStyle) then
        {self.}XmlChildCnfStyle.ConvertToPoint();
    if not ifnil({self.}XmlChildIns) then
        {self.}XmlChildIns.ConvertToPoint();
    if not ifnil({self.}XmlChildDel) then
        {self.}XmlChildDel.ConvertToPoint();
end;

function TrPr.ReadXmlChildTblHeader();
begin
    if tslassigning and (ifnil({self.}XmlChildTblHeader) or {self.}XmlChildTblHeader.Removed) then
    begin
        {self.}XmlChildTblHeader := new OpenXmlSimpleType(self, {self.}Prefix, "tblHeader");
        container_.Set({self.}XmlChildTblHeader);
    end
    return {self.}XmlChildTblHeader and not {self.}XmlChildTblHeader.Removed ? {self.}XmlChildTblHeader : fallback_.XmlChildTblHeader;
end;

function TrPr.WriteXmlChildTblHeader(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildTblHeader) then
            {self.}RemoveChild({self.}XmlChildTblHeader);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildTblHeader := _value;
        container_.Set({self.}XmlChildTblHeader);
    end
    else begin
        raise "Invalid assignment: TblHeader expects nil or OpenXmlSimpleType";
    end
end;

function TrPr.ReadXmlChildCantSplit();
begin
    if tslassigning and (ifnil({self.}XmlChildCantSplit) or {self.}XmlChildCantSplit.Removed) then
    begin
        {self.}XmlChildCantSplit := new OpenXmlSimpleType(self, {self.}Prefix, "cantSplit");
        container_.Set({self.}XmlChildCantSplit);
    end
    return {self.}XmlChildCantSplit and not {self.}XmlChildCantSplit.Removed ? {self.}XmlChildCantSplit : fallback_.XmlChildCantSplit;
end;

function TrPr.WriteXmlChildCantSplit(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildCantSplit) then
            {self.}RemoveChild({self.}XmlChildCantSplit);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildCantSplit := _value;
        container_.Set({self.}XmlChildCantSplit);
    end
    else begin
        raise "Invalid assignment: CantSplit expects nil or OpenXmlSimpleType";
    end
end;

function TrPr.ReadXmlChildTrHeight(): TrHeight;
begin
    if tslassigning and (ifnil({self.}XmlChildTrHeight) or {self.}XmlChildTrHeight.Removed) then
    begin
        {self.}XmlChildTrHeight := new TrHeight(self, {self.}Prefix, "trHeight");
        container_.Set({self.}XmlChildTrHeight);
    end
    return {self.}XmlChildTrHeight and not {self.}XmlChildTrHeight.Removed ? {self.}XmlChildTrHeight : fallback_.XmlChildTrHeight;
end;

function TrPr.WriteXmlChildTrHeight(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTrHeight) then
            {self.}RemoveChild({self.}XmlChildTrHeight);
    end
    else if v is class(TrHeight) then
    begin
        {self.}XmlChildTrHeight := v;
        container_.Set({self.}XmlChildTrHeight);
    end
    else begin
        raise "Invalid assignment: TrHeight expects TrHeight or nil";
    end
end;

function TrPr.ReadXmlChildJc(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildJc) or {self.}XmlChildJc.Removed) then
    begin
        {self.}XmlChildJc := new PureWVal(self, {self.}Prefix, "jc");
        container_.Set({self.}XmlChildJc);
    end
    return {self.}XmlChildJc and not {self.}XmlChildJc.Removed ? {self.}XmlChildJc : fallback_.XmlChildJc;
end;

function TrPr.WriteXmlChildJc(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildJc) then
            {self.}RemoveChild({self.}XmlChildJc);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildJc := v;
        container_.Set({self.}XmlChildJc);
    end
    else begin
        raise "Invalid assignment: Jc expects PureWVal or nil";
    end
end;

function TrPr.ReadXmlChildCnfStyle(): CnfStyle;
begin
    if tslassigning and (ifnil({self.}XmlChildCnfStyle) or {self.}XmlChildCnfStyle.Removed) then
    begin
        {self.}XmlChildCnfStyle := new CnfStyle(self, {self.}Prefix, "cnfStyle");
        container_.Set({self.}XmlChildCnfStyle);
    end
    return {self.}XmlChildCnfStyle and not {self.}XmlChildCnfStyle.Removed ? {self.}XmlChildCnfStyle : fallback_.XmlChildCnfStyle;
end;

function TrPr.WriteXmlChildCnfStyle(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildCnfStyle) then
            {self.}RemoveChild({self.}XmlChildCnfStyle);
    end
    else if v is class(CnfStyle) then
    begin
        {self.}XmlChildCnfStyle := v;
        container_.Set({self.}XmlChildCnfStyle);
    end
    else begin
        raise "Invalid assignment: CnfStyle expects CnfStyle or nil";
    end
end;

function TrPr.ReadXmlChildIns(): Ins;
begin
    if tslassigning and (ifnil({self.}XmlChildIns) or {self.}XmlChildIns.Removed) then
    begin
        {self.}XmlChildIns := new Ins(self, {self.}Prefix, "ins");
        container_.Set({self.}XmlChildIns);
    end
    return {self.}XmlChildIns and not {self.}XmlChildIns.Removed ? {self.}XmlChildIns : fallback_.XmlChildIns;
end;

function TrPr.WriteXmlChildIns(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildIns) then
            {self.}RemoveChild({self.}XmlChildIns);
    end
    else if v is class(Ins) then
    begin
        {self.}XmlChildIns := v;
        container_.Set({self.}XmlChildIns);
    end
    else begin
        raise "Invalid assignment: Ins expects Ins or nil";
    end
end;

function TrPr.ReadXmlChildDel(): Del;
begin
    if tslassigning and (ifnil({self.}XmlChildDel) or {self.}XmlChildDel.Removed) then
    begin
        {self.}XmlChildDel := new Del(self, {self.}Prefix, "del");
        container_.Set({self.}XmlChildDel);
    end
    return {self.}XmlChildDel and not {self.}XmlChildDel.Removed ? {self.}XmlChildDel : fallback_.XmlChildDel;
end;

function TrPr.WriteXmlChildDel(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildDel) then
            {self.}RemoveChild({self.}XmlChildDel);
    end
    else if v is class(Del) then
    begin
        {self.}XmlChildDel := v;
        container_.Set({self.}XmlChildDel);
    end
    else begin
        raise "Invalid assignment: Del expects Del or nil";
    end
end;

function Ins.Create();overload;
begin
    {self.}Create(nil, "w", "ins");
end;

function Ins.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Ins.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Ins.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "id": makeweakref(thisFunction(WriteXmlAttrId)),
        pre + "author": makeweakref(thisFunction(WriteXmlAttrAuthor)),
        pre + "date": makeweakref(thisFunction(WriteXmlAttrDate)),
        "w16du:dateUtc": makeweakref(thisFunction(WriteXmlAttrDateUtc)),
    );
    sorted_child_ := array(
        pre + "r": array(0, makeweakref(thisFunction(AppendR))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Ins.Copy(_obj: Ins);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Id) then
        {self.}Id := _obj.Id;
    if not ifnil(_obj.Author) then
        {self.}Author := _obj.Author;
    if not ifnil(_obj.Date) then
        {self.}Date := _obj.Date;
    if not ifnil(_obj.DateUtc) then
        {self.}DateUtc := _obj.DateUtc;
    tslassigning := tslassigning_backup;
end;

function Ins.ConvertToPoint();override;
begin
    elems := {self.}Rs();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Ins.ReadXmlAttrId();
begin
    return ifnil({self.}XmlAttrId.Value) ? fallback_.XmlAttrId.Value : {self.}XmlAttrId.Value;
end;

function Ins.WriteXmlAttrId(_value: any);
begin
    if ifnil({self.}XmlAttrId) then
    begin
        {self.}XmlAttrId := new OpenXmlAttribute({self.}Prefix, "id", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "id" : "id"] := {self.}XmlAttrId;
    end
    {self.}XmlAttrId.Value := _value;
end;

function Ins.ReadXmlAttrAuthor();
begin
    return ifnil({self.}XmlAttrAuthor.Value) ? fallback_.XmlAttrAuthor.Value : {self.}XmlAttrAuthor.Value;
end;

function Ins.WriteXmlAttrAuthor(_value: any);
begin
    if ifnil({self.}XmlAttrAuthor) then
    begin
        {self.}XmlAttrAuthor := new OpenXmlAttribute({self.}Prefix, "author", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "author" : "author"] := {self.}XmlAttrAuthor;
    end
    {self.}XmlAttrAuthor.Value := _value;
end;

function Ins.ReadXmlAttrDate();
begin
    return ifnil({self.}XmlAttrDate.Value) ? fallback_.XmlAttrDate.Value : {self.}XmlAttrDate.Value;
end;

function Ins.WriteXmlAttrDate(_value: any);
begin
    if ifnil({self.}XmlAttrDate) then
    begin
        {self.}XmlAttrDate := new OpenXmlAttribute({self.}Prefix, "date", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "date" : "date"] := {self.}XmlAttrDate;
    end
    {self.}XmlAttrDate.Value := _value;
end;

function Ins.ReadXmlAttrDateUtc();
begin
    return ifnil({self.}XmlAttrDateUtc.Value) ? fallback_.XmlAttrDateUtc.Value : {self.}XmlAttrDateUtc.Value;
end;

function Ins.WriteXmlAttrDateUtc(_value: any);
begin
    if ifnil({self.}XmlAttrDateUtc) then
    begin
        {self.}XmlAttrDateUtc := new OpenXmlAttribute("w16du", "dateUtc", nil);
        attributes_["w16du:dateUtc"] := {self.}XmlAttrDateUtc;
    end
    {self.}XmlAttrDateUtc.Value := _value;
end;

function Ins.ReadRs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "r", ind);
end;

function Ins.WriteRs(_index: integer; _value: nil_OR_R);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadRs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "r", ind, _value) then
            raise format("Index out of range: Rs[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Rs expects nil or R";
    end
end;

function Ins.AddR(): R;
begin
    obj := new R(self, {self.}Prefix, "r");
    container_.Insert(obj);
    return obj;
end;

function Ins.AppendR(): R;
begin
    obj := new R(self, {self.}Prefix, "r");
    container_.Append(obj);
    return obj;
end;

function CnfStyle.Create();overload;
begin
    {self.}Create(nil, "w", "cnfStyle");
end;

function CnfStyle.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function CnfStyle.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function CnfStyle.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "val": makeweakref(thisFunction(WriteXmlAttrVal)),
        pre + "firstRow": makeweakref(thisFunction(WriteXmlAttrFirstRow)),
        pre + "lastRow": makeweakref(thisFunction(WriteXmlAttrLastRow)),
        pre + "firstColumn": makeweakref(thisFunction(WriteXmlAttrFirstColumn)),
        pre + "lastColumn": makeweakref(thisFunction(WriteXmlAttrLastColumn)),
        pre + "oddVBand": makeweakref(thisFunction(WriteXmlAttrOddVBand)),
        pre + "evenVBand": makeweakref(thisFunction(WriteXmlAttrEvenVBand)),
        pre + "oddHBand": makeweakref(thisFunction(WriteXmlAttrOddHBand)),
        pre + "evenHBand": makeweakref(thisFunction(WriteXmlAttrEvenHBand)),
        pre + "firstRowFirstColumn": makeweakref(thisFunction(WriteXmlAttrFirstRowFirstColumn)),
        pre + "firstRowLastColumn": makeweakref(thisFunction(WriteXmlAttrFirstRowLastColumn)),
        pre + "lastRowFirstColumn": makeweakref(thisFunction(WriteXmlAttrLastRowFirstColumn)),
        pre + "lastRowLastColumn": makeweakref(thisFunction(WriteXmlAttrLastRowLastColumn)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function CnfStyle.Copy(_obj: CnfStyle);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    if not ifnil(_obj.FirstRow) then
        {self.}FirstRow := _obj.FirstRow;
    if not ifnil(_obj.LastRow) then
        {self.}LastRow := _obj.LastRow;
    if not ifnil(_obj.FirstColumn) then
        {self.}FirstColumn := _obj.FirstColumn;
    if not ifnil(_obj.LastColumn) then
        {self.}LastColumn := _obj.LastColumn;
    if not ifnil(_obj.OddVBand) then
        {self.}OddVBand := _obj.OddVBand;
    if not ifnil(_obj.EvenVBand) then
        {self.}EvenVBand := _obj.EvenVBand;
    if not ifnil(_obj.OddHBand) then
        {self.}OddHBand := _obj.OddHBand;
    if not ifnil(_obj.EvenHBand) then
        {self.}EvenHBand := _obj.EvenHBand;
    if not ifnil(_obj.FirstRowFirstColumn) then
        {self.}FirstRowFirstColumn := _obj.FirstRowFirstColumn;
    if not ifnil(_obj.FirstRowLastColumn) then
        {self.}FirstRowLastColumn := _obj.FirstRowLastColumn;
    if not ifnil(_obj.LastRowFirstColumn) then
        {self.}LastRowFirstColumn := _obj.LastRowFirstColumn;
    if not ifnil(_obj.LastRowLastColumn) then
        {self.}LastRowLastColumn := _obj.LastRowLastColumn;
    tslassigning := tslassigning_backup;
end;

function CnfStyle.ConvertToPoint();override;
begin

end;

function CnfStyle.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function CnfStyle.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute({self.}Prefix, "val", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "val" : "val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function CnfStyle.ReadXmlAttrFirstRow();
begin
    return ifnil({self.}XmlAttrFirstRow.Value) ? fallback_.XmlAttrFirstRow.Value : {self.}XmlAttrFirstRow.Value;
end;

function CnfStyle.WriteXmlAttrFirstRow(_value: any);
begin
    if ifnil({self.}XmlAttrFirstRow) then
    begin
        {self.}XmlAttrFirstRow := new OpenXmlAttribute({self.}Prefix, "firstRow", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "firstRow" : "firstRow"] := {self.}XmlAttrFirstRow;
    end
    {self.}XmlAttrFirstRow.Value := _value;
end;

function CnfStyle.ReadXmlAttrLastRow();
begin
    return ifnil({self.}XmlAttrLastRow.Value) ? fallback_.XmlAttrLastRow.Value : {self.}XmlAttrLastRow.Value;
end;

function CnfStyle.WriteXmlAttrLastRow(_value: any);
begin
    if ifnil({self.}XmlAttrLastRow) then
    begin
        {self.}XmlAttrLastRow := new OpenXmlAttribute({self.}Prefix, "lastRow", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "lastRow" : "lastRow"] := {self.}XmlAttrLastRow;
    end
    {self.}XmlAttrLastRow.Value := _value;
end;

function CnfStyle.ReadXmlAttrFirstColumn();
begin
    return ifnil({self.}XmlAttrFirstColumn.Value) ? fallback_.XmlAttrFirstColumn.Value : {self.}XmlAttrFirstColumn.Value;
end;

function CnfStyle.WriteXmlAttrFirstColumn(_value: any);
begin
    if ifnil({self.}XmlAttrFirstColumn) then
    begin
        {self.}XmlAttrFirstColumn := new OpenXmlAttribute({self.}Prefix, "firstColumn", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "firstColumn" : "firstColumn"] := {self.}XmlAttrFirstColumn;
    end
    {self.}XmlAttrFirstColumn.Value := _value;
end;

function CnfStyle.ReadXmlAttrLastColumn();
begin
    return ifnil({self.}XmlAttrLastColumn.Value) ? fallback_.XmlAttrLastColumn.Value : {self.}XmlAttrLastColumn.Value;
end;

function CnfStyle.WriteXmlAttrLastColumn(_value: any);
begin
    if ifnil({self.}XmlAttrLastColumn) then
    begin
        {self.}XmlAttrLastColumn := new OpenXmlAttribute({self.}Prefix, "lastColumn", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "lastColumn" : "lastColumn"] := {self.}XmlAttrLastColumn;
    end
    {self.}XmlAttrLastColumn.Value := _value;
end;

function CnfStyle.ReadXmlAttrOddVBand();
begin
    return ifnil({self.}XmlAttrOddVBand.Value) ? fallback_.XmlAttrOddVBand.Value : {self.}XmlAttrOddVBand.Value;
end;

function CnfStyle.WriteXmlAttrOddVBand(_value: any);
begin
    if ifnil({self.}XmlAttrOddVBand) then
    begin
        {self.}XmlAttrOddVBand := new OpenXmlAttribute({self.}Prefix, "oddVBand", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "oddVBand" : "oddVBand"] := {self.}XmlAttrOddVBand;
    end
    {self.}XmlAttrOddVBand.Value := _value;
end;

function CnfStyle.ReadXmlAttrEvenVBand();
begin
    return ifnil({self.}XmlAttrEvenVBand.Value) ? fallback_.XmlAttrEvenVBand.Value : {self.}XmlAttrEvenVBand.Value;
end;

function CnfStyle.WriteXmlAttrEvenVBand(_value: any);
begin
    if ifnil({self.}XmlAttrEvenVBand) then
    begin
        {self.}XmlAttrEvenVBand := new OpenXmlAttribute({self.}Prefix, "evenVBand", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "evenVBand" : "evenVBand"] := {self.}XmlAttrEvenVBand;
    end
    {self.}XmlAttrEvenVBand.Value := _value;
end;

function CnfStyle.ReadXmlAttrOddHBand();
begin
    return ifnil({self.}XmlAttrOddHBand.Value) ? fallback_.XmlAttrOddHBand.Value : {self.}XmlAttrOddHBand.Value;
end;

function CnfStyle.WriteXmlAttrOddHBand(_value: any);
begin
    if ifnil({self.}XmlAttrOddHBand) then
    begin
        {self.}XmlAttrOddHBand := new OpenXmlAttribute({self.}Prefix, "oddHBand", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "oddHBand" : "oddHBand"] := {self.}XmlAttrOddHBand;
    end
    {self.}XmlAttrOddHBand.Value := _value;
end;

function CnfStyle.ReadXmlAttrEvenHBand();
begin
    return ifnil({self.}XmlAttrEvenHBand.Value) ? fallback_.XmlAttrEvenHBand.Value : {self.}XmlAttrEvenHBand.Value;
end;

function CnfStyle.WriteXmlAttrEvenHBand(_value: any);
begin
    if ifnil({self.}XmlAttrEvenHBand) then
    begin
        {self.}XmlAttrEvenHBand := new OpenXmlAttribute({self.}Prefix, "evenHBand", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "evenHBand" : "evenHBand"] := {self.}XmlAttrEvenHBand;
    end
    {self.}XmlAttrEvenHBand.Value := _value;
end;

function CnfStyle.ReadXmlAttrFirstRowFirstColumn();
begin
    return ifnil({self.}XmlAttrFirstRowFirstColumn.Value) ? fallback_.XmlAttrFirstRowFirstColumn.Value : {self.}XmlAttrFirstRowFirstColumn.Value;
end;

function CnfStyle.WriteXmlAttrFirstRowFirstColumn(_value: any);
begin
    if ifnil({self.}XmlAttrFirstRowFirstColumn) then
    begin
        {self.}XmlAttrFirstRowFirstColumn := new OpenXmlAttribute({self.}Prefix, "firstRowFirstColumn", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "firstRowFirstColumn" : "firstRowFirstColumn"] := {self.}XmlAttrFirstRowFirstColumn;
    end
    {self.}XmlAttrFirstRowFirstColumn.Value := _value;
end;

function CnfStyle.ReadXmlAttrFirstRowLastColumn();
begin
    return ifnil({self.}XmlAttrFirstRowLastColumn.Value) ? fallback_.XmlAttrFirstRowLastColumn.Value : {self.}XmlAttrFirstRowLastColumn.Value;
end;

function CnfStyle.WriteXmlAttrFirstRowLastColumn(_value: any);
begin
    if ifnil({self.}XmlAttrFirstRowLastColumn) then
    begin
        {self.}XmlAttrFirstRowLastColumn := new OpenXmlAttribute({self.}Prefix, "firstRowLastColumn", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "firstRowLastColumn" : "firstRowLastColumn"] := {self.}XmlAttrFirstRowLastColumn;
    end
    {self.}XmlAttrFirstRowLastColumn.Value := _value;
end;

function CnfStyle.ReadXmlAttrLastRowFirstColumn();
begin
    return ifnil({self.}XmlAttrLastRowFirstColumn.Value) ? fallback_.XmlAttrLastRowFirstColumn.Value : {self.}XmlAttrLastRowFirstColumn.Value;
end;

function CnfStyle.WriteXmlAttrLastRowFirstColumn(_value: any);
begin
    if ifnil({self.}XmlAttrLastRowFirstColumn) then
    begin
        {self.}XmlAttrLastRowFirstColumn := new OpenXmlAttribute({self.}Prefix, "lastRowFirstColumn", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "lastRowFirstColumn" : "lastRowFirstColumn"] := {self.}XmlAttrLastRowFirstColumn;
    end
    {self.}XmlAttrLastRowFirstColumn.Value := _value;
end;

function CnfStyle.ReadXmlAttrLastRowLastColumn();
begin
    return ifnil({self.}XmlAttrLastRowLastColumn.Value) ? fallback_.XmlAttrLastRowLastColumn.Value : {self.}XmlAttrLastRowLastColumn.Value;
end;

function CnfStyle.WriteXmlAttrLastRowLastColumn(_value: any);
begin
    if ifnil({self.}XmlAttrLastRowLastColumn) then
    begin
        {self.}XmlAttrLastRowLastColumn := new OpenXmlAttribute({self.}Prefix, "lastRowLastColumn", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "lastRowLastColumn" : "lastRowLastColumn"] := {self.}XmlAttrLastRowLastColumn;
    end
    {self.}XmlAttrLastRowLastColumn.Value := _value;
end;

function TrHeight.Create();overload;
begin
    {self.}Create(nil, "w", "trHeight");
end;

function TrHeight.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TrHeight.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TrHeight.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "hRule": makeweakref(thisFunction(WriteXmlAttrHRule)),
        pre + "val": makeweakref(thisFunction(WriteXmlAttrval)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TrHeight.Copy(_obj: TrHeight);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.HRule) then
        {self.}HRule := _obj.HRule;
    if not ifnil(_obj.val) then
        {self.}val := _obj.val;
    tslassigning := tslassigning_backup;
end;

function TrHeight.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrval) then
        {self.}val := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrval.Value);
end;

function TrHeight.ReadXmlAttrHRule();
begin
    return ifnil({self.}XmlAttrHRule.Value) ? fallback_.XmlAttrHRule.Value : {self.}XmlAttrHRule.Value;
end;

function TrHeight.WriteXmlAttrHRule(_value: any);
begin
    if ifnil({self.}XmlAttrHRule) then
    begin
        {self.}XmlAttrHRule := new OpenXmlAttribute({self.}Prefix, "hRule", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "hRule" : "hRule"] := {self.}XmlAttrHRule;
    end
    {self.}XmlAttrHRule.Value := _value;
end;

function TrHeight.ReadXmlAttrval();
begin
    return ifnil({self.}XmlAttrval.Value) ? fallback_.XmlAttrval.Value : {self.}XmlAttrval.Value;
end;

function TrHeight.WriteXmlAttrval(_value: any);
begin
    if ifnil({self.}XmlAttrval) then
    begin
        {self.}XmlAttrval := new OpenXmlAttribute({self.}Prefix, "val", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "val" : "val"] := {self.}XmlAttrval;
    end
    {self.}XmlAttrval.Value := _value;
end;

function Tc.Create();overload;
begin
    {self.}Create(nil, "w", "tc");
end;

function Tc.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Tc.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Tc.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "tcPr": array(0, makeweakref(thisFunction(ReadXmlChildTcPr))),
        pre + "p": array(1, makeweakref(thisFunction(AppendP))),
        pre + "tbl": array(2, makeweakref(thisFunction(AppendTbl))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Tc.Copy(_obj: Tc);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildTcPr) then
        {self.}TcPr.Copy(_obj.XmlChildTcPr);
    tslassigning := tslassigning_backup;
end;

function Tc.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildTcPr) then
        {self.}XmlChildTcPr.ConvertToPoint();
    elems := {self.}Ps();
    for _,elem in elems do
        elem.ConvertToPoint();
    elems := {self.}Tbls();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Tc.ReadXmlChildTcPr(): TcPr;
begin
    if tslassigning and (ifnil({self.}XmlChildTcPr) or {self.}XmlChildTcPr.Removed) then
    begin
        {self.}XmlChildTcPr := new TcPr(self, {self.}Prefix, "tcPr");
        container_.Set({self.}XmlChildTcPr);
    end
    return {self.}XmlChildTcPr and not {self.}XmlChildTcPr.Removed ? {self.}XmlChildTcPr : fallback_.XmlChildTcPr;
end;

function Tc.WriteXmlChildTcPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTcPr) then
            {self.}RemoveChild({self.}XmlChildTcPr);
    end
    else if v is class(TcPr) then
    begin
        {self.}XmlChildTcPr := v;
        container_.Set({self.}XmlChildTcPr);
    end
    else begin
        raise "Invalid assignment: TcPr expects TcPr or nil";
    end
end;

function Tc.ReadPs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "p", ind);
end;

function Tc.WritePs(_index: integer; _value: nil_OR_P);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadPs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "p", ind, _value) then
            raise format("Index out of range: Ps[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Ps expects nil or P";
    end
end;

function Tc.ReadTbls(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "tbl", ind);
end;

function Tc.WriteTbls(_index: integer; _value: nil_OR_Tbl);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadTbls(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "tbl", ind, _value) then
            raise format("Index out of range: Tbls[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Tbls expects nil or Tbl";
    end
end;

function Tc.AddP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Insert(obj);
    return obj;
end;

function Tc.AddTbl(): Tbl;
begin
    obj := new Tbl(self, {self.}Prefix, "tbl");
    container_.Insert(obj);
    return obj;
end;

function Tc.AppendP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Append(obj);
    return obj;
end;

function Tc.AppendTbl(): Tbl;
begin
    obj := new Tbl(self, {self.}Prefix, "tbl");
    container_.Append(obj);
    return obj;
end;

function TcPr.Create();overload;
begin
    {self.}Create(nil, "w", "tcPr");
end;

function TcPr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TcPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TcPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "tcW": array(0, makeweakref(thisFunction(ReadXmlChildTcW))),
        pre + "gridSpan": array(1, makeweakref(thisFunction(ReadXmlChildGridSpan))),
        pre + "vMerge": array(2, makeweakref(thisFunction(ReadXmlChildVMerge))),
        pre + "vAlign": array(3, makeweakref(thisFunction(ReadXmlChildVAlign))),
        pre + "hideMark": array(4, makeweakref(thisFunction(ReadXmlChildHideMark))),
        pre + "shd": array(5, makeweakref(thisFunction(ReadXmlChildShd))),
        pre + "tcBorders": array(6, makeweakref(thisFunction(ReadXmlChildTcBorders))),
        pre + "textDirection": array(7, makeweakref(thisFunction(ReadXmlChildTextDirection))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TcPr.Copy(_obj: TcPr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildTcW) then
        {self.}TcW.Copy(_obj.XmlChildTcW);
    if not ifnil(_obj.XmlChildGridSpan) then
        {self.}GridSpan.Copy(_obj.XmlChildGridSpan);
    if not ifnil(_obj.XmlChildVMerge) then
        ifnil({self.}XmlChildVMerge) ? {self.}VMerge.Copy(_obj.XmlChildVMerge) : {self.}XmlChildVMerge.Copy(_obj.XmlChildVMerge);
    if not ifnil(_obj.XmlChildVAlign) then
        {self.}VAlign.Copy(_obj.XmlChildVAlign);
    if not ifnil(_obj.XmlChildHideMark) then
        ifnil({self.}XmlChildHideMark) ? {self.}HideMark.Copy(_obj.XmlChildHideMark) : {self.}XmlChildHideMark.Copy(_obj.XmlChildHideMark);
    if not ifnil(_obj.XmlChildShd) then
        {self.}Shd.Copy(_obj.XmlChildShd);
    if not ifnil(_obj.XmlChildTcBorders) then
        {self.}TcBorders.Copy(_obj.XmlChildTcBorders);
    if not ifnil(_obj.XmlChildTextDirection) then
        {self.}TextDirection.Copy(_obj.XmlChildTextDirection);
    tslassigning := tslassigning_backup;
end;

function TcPr.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildTcW) then
        {self.}XmlChildTcW.ConvertToPoint();
    if not ifnil({self.}XmlChildGridSpan) then
        {self.}XmlChildGridSpan.ConvertToPoint();
    if not ifnil({self.}XmlChildVAlign) then
        {self.}XmlChildVAlign.ConvertToPoint();
    if not ifnil({self.}XmlChildShd) then
        {self.}XmlChildShd.ConvertToPoint();
    if not ifnil({self.}XmlChildTcBorders) then
        {self.}XmlChildTcBorders.ConvertToPoint();
    if not ifnil({self.}XmlChildTextDirection) then
        {self.}XmlChildTextDirection.ConvertToPoint();
end;

function TcPr.ReadXmlChildVMerge();
begin
    if tslassigning and (ifnil({self.}XmlChildVMerge) or {self.}XmlChildVMerge.Removed) then
    begin
        {self.}XmlChildVMerge := new OpenXmlSimpleType(self, {self.}Prefix, "vMerge");
        container_.Set({self.}XmlChildVMerge);
    end
    return {self.}XmlChildVMerge and not {self.}XmlChildVMerge.Removed ? {self.}XmlChildVMerge : fallback_.XmlChildVMerge;
end;

function TcPr.WriteXmlChildVMerge(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildVMerge) then
            {self.}RemoveChild({self.}XmlChildVMerge);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildVMerge := _value;
        container_.Set({self.}XmlChildVMerge);
    end
    else begin
        raise "Invalid assignment: VMerge expects nil or OpenXmlSimpleType";
    end
end;

function TcPr.ReadXmlChildHideMark();
begin
    if tslassigning and (ifnil({self.}XmlChildHideMark) or {self.}XmlChildHideMark.Removed) then
    begin
        {self.}XmlChildHideMark := new OpenXmlSimpleType(self, {self.}Prefix, "hideMark");
        container_.Set({self.}XmlChildHideMark);
    end
    return {self.}XmlChildHideMark and not {self.}XmlChildHideMark.Removed ? {self.}XmlChildHideMark : fallback_.XmlChildHideMark;
end;

function TcPr.WriteXmlChildHideMark(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildHideMark) then
            {self.}RemoveChild({self.}XmlChildHideMark);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildHideMark := _value;
        container_.Set({self.}XmlChildHideMark);
    end
    else begin
        raise "Invalid assignment: HideMark expects nil or OpenXmlSimpleType";
    end
end;

function TcPr.ReadXmlChildTcW(): TblW;
begin
    if tslassigning and (ifnil({self.}XmlChildTcW) or {self.}XmlChildTcW.Removed) then
    begin
        {self.}XmlChildTcW := new TblW(self, {self.}Prefix, "tcW");
        container_.Set({self.}XmlChildTcW);
    end
    return {self.}XmlChildTcW and not {self.}XmlChildTcW.Removed ? {self.}XmlChildTcW : fallback_.XmlChildTcW;
end;

function TcPr.WriteXmlChildTcW(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTcW) then
            {self.}RemoveChild({self.}XmlChildTcW);
    end
    else if v is class(TblW) then
    begin
        {self.}XmlChildTcW := v;
        container_.Set({self.}XmlChildTcW);
    end
    else begin
        raise "Invalid assignment: TcW expects TblW or nil";
    end
end;

function TcPr.ReadXmlChildGridSpan(): GridSpan;
begin
    if tslassigning and (ifnil({self.}XmlChildGridSpan) or {self.}XmlChildGridSpan.Removed) then
    begin
        {self.}XmlChildGridSpan := new GridSpan(self, {self.}Prefix, "gridSpan");
        container_.Set({self.}XmlChildGridSpan);
    end
    return {self.}XmlChildGridSpan and not {self.}XmlChildGridSpan.Removed ? {self.}XmlChildGridSpan : fallback_.XmlChildGridSpan;
end;

function TcPr.WriteXmlChildGridSpan(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildGridSpan) then
            {self.}RemoveChild({self.}XmlChildGridSpan);
    end
    else if v is class(GridSpan) then
    begin
        {self.}XmlChildGridSpan := v;
        container_.Set({self.}XmlChildGridSpan);
    end
    else begin
        raise "Invalid assignment: GridSpan expects GridSpan or nil";
    end
end;

function TcPr.ReadXmlChildVAlign(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildVAlign) or {self.}XmlChildVAlign.Removed) then
    begin
        {self.}XmlChildVAlign := new PureWVal(self, {self.}Prefix, "vAlign");
        container_.Set({self.}XmlChildVAlign);
    end
    return {self.}XmlChildVAlign and not {self.}XmlChildVAlign.Removed ? {self.}XmlChildVAlign : fallback_.XmlChildVAlign;
end;

function TcPr.WriteXmlChildVAlign(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildVAlign) then
            {self.}RemoveChild({self.}XmlChildVAlign);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildVAlign := v;
        container_.Set({self.}XmlChildVAlign);
    end
    else begin
        raise "Invalid assignment: VAlign expects PureWVal or nil";
    end
end;

function TcPr.ReadXmlChildShd(): Shd;
begin
    if tslassigning and (ifnil({self.}XmlChildShd) or {self.}XmlChildShd.Removed) then
    begin
        {self.}XmlChildShd := new Shd(self, {self.}Prefix, "shd");
        container_.Set({self.}XmlChildShd);
    end
    return {self.}XmlChildShd and not {self.}XmlChildShd.Removed ? {self.}XmlChildShd : fallback_.XmlChildShd;
end;

function TcPr.WriteXmlChildShd(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildShd) then
            {self.}RemoveChild({self.}XmlChildShd);
    end
    else if v is class(Shd) then
    begin
        {self.}XmlChildShd := v;
        container_.Set({self.}XmlChildShd);
    end
    else begin
        raise "Invalid assignment: Shd expects Shd or nil";
    end
end;

function TcPr.ReadXmlChildTcBorders(): TcBorders;
begin
    if tslassigning and (ifnil({self.}XmlChildTcBorders) or {self.}XmlChildTcBorders.Removed) then
    begin
        {self.}XmlChildTcBorders := new TcBorders(self, {self.}Prefix, "tcBorders");
        container_.Set({self.}XmlChildTcBorders);
    end
    return {self.}XmlChildTcBorders and not {self.}XmlChildTcBorders.Removed ? {self.}XmlChildTcBorders : fallback_.XmlChildTcBorders;
end;

function TcPr.WriteXmlChildTcBorders(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTcBorders) then
            {self.}RemoveChild({self.}XmlChildTcBorders);
    end
    else if v is class(TcBorders) then
    begin
        {self.}XmlChildTcBorders := v;
        container_.Set({self.}XmlChildTcBorders);
    end
    else begin
        raise "Invalid assignment: TcBorders expects TcBorders or nil";
    end
end;

function TcPr.ReadXmlChildTextDirection(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildTextDirection) or {self.}XmlChildTextDirection.Removed) then
    begin
        {self.}XmlChildTextDirection := new PureWVal(self, {self.}Prefix, "textDirection");
        container_.Set({self.}XmlChildTextDirection);
    end
    return {self.}XmlChildTextDirection and not {self.}XmlChildTextDirection.Removed ? {self.}XmlChildTextDirection : fallback_.XmlChildTextDirection;
end;

function TcPr.WriteXmlChildTextDirection(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTextDirection) then
            {self.}RemoveChild({self.}XmlChildTextDirection);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildTextDirection := v;
        container_.Set({self.}XmlChildTextDirection);
    end
    else begin
        raise "Invalid assignment: TextDirection expects PureWVal or nil";
    end
end;

function TcBorders.Create();overload;
begin
    {self.}Create(nil, "w", "tcBorders");
end;

function TcBorders.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TcBorders.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TcBorders.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "top": array(0, makeweakref(thisFunction(ReadXmlChildTop))),
        pre + "left": array(1, makeweakref(thisFunction(ReadXmlChildLeft))),
        pre + "bottom": array(2, makeweakref(thisFunction(ReadXmlChildBottom))),
        pre + "right": array(3, makeweakref(thisFunction(ReadXmlChildRight))),
        pre + "tl2br": array(4, makeweakref(thisFunction(ReadXmlChildTl2Br))),
        pre + "tr2bl": array(5, makeweakref(thisFunction(ReadXmlChildTr2Bl))),
        pre + "insideH": array(6, makeweakref(thisFunction(ReadXmlChildInsideH))),
        pre + "insideV": array(7, makeweakref(thisFunction(ReadXmlChildInsideV))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TcBorders.Copy(_obj: TcBorders);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildTop) then
        {self.}Top.Copy(_obj.XmlChildTop);
    if not ifnil(_obj.XmlChildLeft) then
        {self.}Left.Copy(_obj.XmlChildLeft);
    if not ifnil(_obj.XmlChildBottom) then
        {self.}Bottom.Copy(_obj.XmlChildBottom);
    if not ifnil(_obj.XmlChildRight) then
        {self.}Right.Copy(_obj.XmlChildRight);
    if not ifnil(_obj.XmlChildTl2Br) then
        {self.}Tl2Br.Copy(_obj.XmlChildTl2Br);
    if not ifnil(_obj.XmlChildTr2Bl) then
        {self.}Tr2Bl.Copy(_obj.XmlChildTr2Bl);
    if not ifnil(_obj.XmlChildInsideH) then
        {self.}InsideH.Copy(_obj.XmlChildInsideH);
    if not ifnil(_obj.XmlChildInsideV) then
        {self.}InsideV.Copy(_obj.XmlChildInsideV);
    tslassigning := tslassigning_backup;
end;

function TcBorders.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildTop) then
        {self.}XmlChildTop.ConvertToPoint();
    if not ifnil({self.}XmlChildLeft) then
        {self.}XmlChildLeft.ConvertToPoint();
    if not ifnil({self.}XmlChildBottom) then
        {self.}XmlChildBottom.ConvertToPoint();
    if not ifnil({self.}XmlChildRight) then
        {self.}XmlChildRight.ConvertToPoint();
    if not ifnil({self.}XmlChildTl2Br) then
        {self.}XmlChildTl2Br.ConvertToPoint();
    if not ifnil({self.}XmlChildTr2Bl) then
        {self.}XmlChildTr2Bl.ConvertToPoint();
    if not ifnil({self.}XmlChildInsideH) then
        {self.}XmlChildInsideH.ConvertToPoint();
    if not ifnil({self.}XmlChildInsideV) then
        {self.}XmlChildInsideV.ConvertToPoint();
end;

function TcBorders.ReadXmlChildTop(): TcBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildTop) or {self.}XmlChildTop.Removed) then
    begin
        {self.}XmlChildTop := new TcBorder(self, {self.}Prefix, "top");
        container_.Set({self.}XmlChildTop);
    end
    return {self.}XmlChildTop and not {self.}XmlChildTop.Removed ? {self.}XmlChildTop : fallback_.XmlChildTop;
end;

function TcBorders.WriteXmlChildTop(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTop) then
            {self.}RemoveChild({self.}XmlChildTop);
    end
    else if v is class(TcBorder) then
    begin
        {self.}XmlChildTop := v;
        container_.Set({self.}XmlChildTop);
    end
    else begin
        raise "Invalid assignment: Top expects TcBorder or nil";
    end
end;

function TcBorders.ReadXmlChildLeft(): TcBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildLeft) or {self.}XmlChildLeft.Removed) then
    begin
        {self.}XmlChildLeft := new TcBorder(self, {self.}Prefix, "left");
        container_.Set({self.}XmlChildLeft);
    end
    return {self.}XmlChildLeft and not {self.}XmlChildLeft.Removed ? {self.}XmlChildLeft : fallback_.XmlChildLeft;
end;

function TcBorders.WriteXmlChildLeft(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildLeft) then
            {self.}RemoveChild({self.}XmlChildLeft);
    end
    else if v is class(TcBorder) then
    begin
        {self.}XmlChildLeft := v;
        container_.Set({self.}XmlChildLeft);
    end
    else begin
        raise "Invalid assignment: Left expects TcBorder or nil";
    end
end;

function TcBorders.ReadXmlChildBottom(): TcBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildBottom) or {self.}XmlChildBottom.Removed) then
    begin
        {self.}XmlChildBottom := new TcBorder(self, {self.}Prefix, "bottom");
        container_.Set({self.}XmlChildBottom);
    end
    return {self.}XmlChildBottom and not {self.}XmlChildBottom.Removed ? {self.}XmlChildBottom : fallback_.XmlChildBottom;
end;

function TcBorders.WriteXmlChildBottom(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildBottom) then
            {self.}RemoveChild({self.}XmlChildBottom);
    end
    else if v is class(TcBorder) then
    begin
        {self.}XmlChildBottom := v;
        container_.Set({self.}XmlChildBottom);
    end
    else begin
        raise "Invalid assignment: Bottom expects TcBorder or nil";
    end
end;

function TcBorders.ReadXmlChildRight(): TcBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildRight) or {self.}XmlChildRight.Removed) then
    begin
        {self.}XmlChildRight := new TcBorder(self, {self.}Prefix, "right");
        container_.Set({self.}XmlChildRight);
    end
    return {self.}XmlChildRight and not {self.}XmlChildRight.Removed ? {self.}XmlChildRight : fallback_.XmlChildRight;
end;

function TcBorders.WriteXmlChildRight(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRight) then
            {self.}RemoveChild({self.}XmlChildRight);
    end
    else if v is class(TcBorder) then
    begin
        {self.}XmlChildRight := v;
        container_.Set({self.}XmlChildRight);
    end
    else begin
        raise "Invalid assignment: Right expects TcBorder or nil";
    end
end;

function TcBorders.ReadXmlChildTl2Br(): TcBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildTl2Br) or {self.}XmlChildTl2Br.Removed) then
    begin
        {self.}XmlChildTl2Br := new TcBorder(self, {self.}Prefix, "tl2br");
        container_.Set({self.}XmlChildTl2Br);
    end
    return {self.}XmlChildTl2Br and not {self.}XmlChildTl2Br.Removed ? {self.}XmlChildTl2Br : fallback_.XmlChildTl2Br;
end;

function TcBorders.WriteXmlChildTl2Br(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTl2Br) then
            {self.}RemoveChild({self.}XmlChildTl2Br);
    end
    else if v is class(TcBorder) then
    begin
        {self.}XmlChildTl2Br := v;
        container_.Set({self.}XmlChildTl2Br);
    end
    else begin
        raise "Invalid assignment: Tl2Br expects TcBorder or nil";
    end
end;

function TcBorders.ReadXmlChildTr2Bl(): TcBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildTr2Bl) or {self.}XmlChildTr2Bl.Removed) then
    begin
        {self.}XmlChildTr2Bl := new TcBorder(self, {self.}Prefix, "tr2bl");
        container_.Set({self.}XmlChildTr2Bl);
    end
    return {self.}XmlChildTr2Bl and not {self.}XmlChildTr2Bl.Removed ? {self.}XmlChildTr2Bl : fallback_.XmlChildTr2Bl;
end;

function TcBorders.WriteXmlChildTr2Bl(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTr2Bl) then
            {self.}RemoveChild({self.}XmlChildTr2Bl);
    end
    else if v is class(TcBorder) then
    begin
        {self.}XmlChildTr2Bl := v;
        container_.Set({self.}XmlChildTr2Bl);
    end
    else begin
        raise "Invalid assignment: Tr2Bl expects TcBorder or nil";
    end
end;

function TcBorders.ReadXmlChildInsideH(): TcBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildInsideH) or {self.}XmlChildInsideH.Removed) then
    begin
        {self.}XmlChildInsideH := new TcBorder(self, {self.}Prefix, "insideH");
        container_.Set({self.}XmlChildInsideH);
    end
    return {self.}XmlChildInsideH and not {self.}XmlChildInsideH.Removed ? {self.}XmlChildInsideH : fallback_.XmlChildInsideH;
end;

function TcBorders.WriteXmlChildInsideH(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildInsideH) then
            {self.}RemoveChild({self.}XmlChildInsideH);
    end
    else if v is class(TcBorder) then
    begin
        {self.}XmlChildInsideH := v;
        container_.Set({self.}XmlChildInsideH);
    end
    else begin
        raise "Invalid assignment: InsideH expects TcBorder or nil";
    end
end;

function TcBorders.ReadXmlChildInsideV(): TcBorder;
begin
    if tslassigning and (ifnil({self.}XmlChildInsideV) or {self.}XmlChildInsideV.Removed) then
    begin
        {self.}XmlChildInsideV := new TcBorder(self, {self.}Prefix, "insideV");
        container_.Set({self.}XmlChildInsideV);
    end
    return {self.}XmlChildInsideV and not {self.}XmlChildInsideV.Removed ? {self.}XmlChildInsideV : fallback_.XmlChildInsideV;
end;

function TcBorders.WriteXmlChildInsideV(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildInsideV) then
            {self.}RemoveChild({self.}XmlChildInsideV);
    end
    else if v is class(TcBorder) then
    begin
        {self.}XmlChildInsideV := v;
        container_.Set({self.}XmlChildInsideV);
    end
    else begin
        raise "Invalid assignment: InsideV expects TcBorder or nil";
    end
end;

function TcBorder.Create();overload;
begin
    {self.}Create(nil, "w", "");
end;

function TcBorder.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TcBorder.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TcBorder.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "val": makeweakref(thisFunction(WriteXmlAttrVal)),
        pre + "color": makeweakref(thisFunction(WriteXmlAttrColor)),
        pre + "space": makeweakref(thisFunction(WriteXmlAttrSpace)),
        pre + "themeColor": makeweakref(thisFunction(WriteXmlAttrThemeColor)),
        pre + "themeTint": makeweakref(thisFunction(WriteXmlAttrThemeTint)),
        pre + "sz": makeweakref(thisFunction(WriteXmlAttrSz)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TcBorder.Copy(_obj: TcBorder);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    if not ifnil(_obj.Color) then
        {self.}Color := _obj.Color;
    if not ifnil(_obj.Space) then
        {self.}Space := _obj.Space;
    if not ifnil(_obj.ThemeColor) then
        {self.}ThemeColor := _obj.ThemeColor;
    if not ifnil(_obj.ThemeTint) then
        {self.}ThemeTint := _obj.ThemeTint;
    if not ifnil(_obj.Sz) then
        {self.}Sz := _obj.Sz;
    tslassigning := tslassigning_backup;
end;

function TcBorder.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrSz) then
        {self.}Sz := TSSafeUnitConverter.EighthPointToPoints({self.}XmlAttrSz.Value);
end;

function TcBorder.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function TcBorder.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute({self.}Prefix, "val", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "val" : "val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function TcBorder.ReadXmlAttrColor();
begin
    return ifnil({self.}XmlAttrColor.Value) ? fallback_.XmlAttrColor.Value : {self.}XmlAttrColor.Value;
end;

function TcBorder.WriteXmlAttrColor(_value: any);
begin
    if ifnil({self.}XmlAttrColor) then
    begin
        {self.}XmlAttrColor := new OpenXmlAttribute({self.}Prefix, "color", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "color" : "color"] := {self.}XmlAttrColor;
    end
    {self.}XmlAttrColor.Value := _value;
end;

function TcBorder.ReadXmlAttrSpace();
begin
    return ifnil({self.}XmlAttrSpace.Value) ? fallback_.XmlAttrSpace.Value : {self.}XmlAttrSpace.Value;
end;

function TcBorder.WriteXmlAttrSpace(_value: any);
begin
    if ifnil({self.}XmlAttrSpace) then
    begin
        {self.}XmlAttrSpace := new OpenXmlAttribute({self.}Prefix, "space", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "space" : "space"] := {self.}XmlAttrSpace;
    end
    {self.}XmlAttrSpace.Value := _value;
end;

function TcBorder.ReadXmlAttrThemeColor();
begin
    return ifnil({self.}XmlAttrThemeColor.Value) ? fallback_.XmlAttrThemeColor.Value : {self.}XmlAttrThemeColor.Value;
end;

function TcBorder.WriteXmlAttrThemeColor(_value: any);
begin
    if ifnil({self.}XmlAttrThemeColor) then
    begin
        {self.}XmlAttrThemeColor := new OpenXmlAttribute({self.}Prefix, "themeColor", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeColor" : "themeColor"] := {self.}XmlAttrThemeColor;
    end
    {self.}XmlAttrThemeColor.Value := _value;
end;

function TcBorder.ReadXmlAttrThemeTint();
begin
    return ifnil({self.}XmlAttrThemeTint.Value) ? fallback_.XmlAttrThemeTint.Value : {self.}XmlAttrThemeTint.Value;
end;

function TcBorder.WriteXmlAttrThemeTint(_value: any);
begin
    if ifnil({self.}XmlAttrThemeTint) then
    begin
        {self.}XmlAttrThemeTint := new OpenXmlAttribute({self.}Prefix, "themeTint", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "themeTint" : "themeTint"] := {self.}XmlAttrThemeTint;
    end
    {self.}XmlAttrThemeTint.Value := _value;
end;

function TcBorder.ReadXmlAttrSz();
begin
    return ifnil({self.}XmlAttrSz.Value) ? fallback_.XmlAttrSz.Value : {self.}XmlAttrSz.Value;
end;

function TcBorder.WriteXmlAttrSz(_value: any);
begin
    if ifnil({self.}XmlAttrSz) then
    begin
        {self.}XmlAttrSz := new OpenXmlAttribute({self.}Prefix, "sz", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "sz" : "sz"] := {self.}XmlAttrSz;
    end
    {self.}XmlAttrSz.Value := _value;
end;

function GridSpan.Create();overload;
begin
    {self.}Create(nil, "w", "gridSpan");
end;

function GridSpan.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function GridSpan.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function GridSpan.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "val": makeweakref(thisFunction(WriteXmlAttrVal)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function GridSpan.Copy(_obj: GridSpan);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    tslassigning := tslassigning_backup;
end;

function GridSpan.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrVal) then
        {self.}Val := TSSafeUnitConverter.ToInt({self.}XmlAttrVal.Value);
end;

function GridSpan.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function GridSpan.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute({self.}Prefix, "val", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "val" : "val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function Sdt.Create();overload;
begin
    {self.}Create(nil, "w", "sdt");
end;

function Sdt.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Sdt.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Sdt.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "sdtPr": array(0, makeweakref(thisFunction(ReadXmlChildSdtPr))),
        pre + "sdtEndPr": array(1, makeweakref(thisFunction(ReadXmlChildSdtEndPr))),
        pre + "sdtContent": array(2, makeweakref(thisFunction(ReadXmlChildSdtContent))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Sdt.Copy(_obj: Sdt);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildSdtPr) then
        {self.}SdtPr.Copy(_obj.XmlChildSdtPr);
    if not ifnil(_obj.XmlChildSdtEndPr) then
        {self.}SdtEndPr.Copy(_obj.XmlChildSdtEndPr);
    if not ifnil(_obj.XmlChildSdtContent) then
        {self.}SdtContent.Copy(_obj.XmlChildSdtContent);
    tslassigning := tslassigning_backup;
end;

function Sdt.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildSdtPr) then
        {self.}XmlChildSdtPr.ConvertToPoint();
    if not ifnil({self.}XmlChildSdtEndPr) then
        {self.}XmlChildSdtEndPr.ConvertToPoint();
    if not ifnil({self.}XmlChildSdtContent) then
        {self.}XmlChildSdtContent.ConvertToPoint();
end;

function Sdt.ReadXmlChildSdtPr(): SdtPr;
begin
    if tslassigning and (ifnil({self.}XmlChildSdtPr) or {self.}XmlChildSdtPr.Removed) then
    begin
        {self.}XmlChildSdtPr := new SdtPr(self, {self.}Prefix, "sdtPr");
        container_.Set({self.}XmlChildSdtPr);
    end
    return {self.}XmlChildSdtPr and not {self.}XmlChildSdtPr.Removed ? {self.}XmlChildSdtPr : fallback_.XmlChildSdtPr;
end;

function Sdt.WriteXmlChildSdtPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildSdtPr) then
            {self.}RemoveChild({self.}XmlChildSdtPr);
    end
    else if v is class(SdtPr) then
    begin
        {self.}XmlChildSdtPr := v;
        container_.Set({self.}XmlChildSdtPr);
    end
    else begin
        raise "Invalid assignment: SdtPr expects SdtPr or nil";
    end
end;

function Sdt.ReadXmlChildSdtEndPr(): SdtEndPr;
begin
    if tslassigning and (ifnil({self.}XmlChildSdtEndPr) or {self.}XmlChildSdtEndPr.Removed) then
    begin
        {self.}XmlChildSdtEndPr := new SdtEndPr(self, {self.}Prefix, "sdtEndPr");
        container_.Set({self.}XmlChildSdtEndPr);
    end
    return {self.}XmlChildSdtEndPr and not {self.}XmlChildSdtEndPr.Removed ? {self.}XmlChildSdtEndPr : fallback_.XmlChildSdtEndPr;
end;

function Sdt.WriteXmlChildSdtEndPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildSdtEndPr) then
            {self.}RemoveChild({self.}XmlChildSdtEndPr);
    end
    else if v is class(SdtEndPr) then
    begin
        {self.}XmlChildSdtEndPr := v;
        container_.Set({self.}XmlChildSdtEndPr);
    end
    else begin
        raise "Invalid assignment: SdtEndPr expects SdtEndPr or nil";
    end
end;

function Sdt.ReadXmlChildSdtContent(): SdtContent;
begin
    if tslassigning and (ifnil({self.}XmlChildSdtContent) or {self.}XmlChildSdtContent.Removed) then
    begin
        {self.}XmlChildSdtContent := new SdtContent(self, {self.}Prefix, "sdtContent");
        container_.Set({self.}XmlChildSdtContent);
    end
    return {self.}XmlChildSdtContent and not {self.}XmlChildSdtContent.Removed ? {self.}XmlChildSdtContent : fallback_.XmlChildSdtContent;
end;

function Sdt.WriteXmlChildSdtContent(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildSdtContent) then
            {self.}RemoveChild({self.}XmlChildSdtContent);
    end
    else if v is class(SdtContent) then
    begin
        {self.}XmlChildSdtContent := v;
        container_.Set({self.}XmlChildSdtContent);
    end
    else begin
        raise "Invalid assignment: SdtContent expects SdtContent or nil";
    end
end;

function SdtPr.Create();overload;
begin
    {self.}Create(nil, "w", "sdtPr");
end;

function SdtPr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function SdtPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function SdtPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "rPr": array(0, makeweakref(thisFunction(ReadXmlChildRPr))),
        pre + "id": array(1, makeweakref(thisFunction(ReadXmlChildId))),
        pre + "docPartObj": array(2, makeweakref(thisFunction(ReadXmlChildDocPartObj))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function SdtPr.Copy(_obj: SdtPr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildRPr) then
        {self.}RPr.Copy(_obj.XmlChildRPr);
    if not ifnil(_obj.XmlChildId) then
        {self.}Id.Copy(_obj.XmlChildId);
    if not ifnil(_obj.XmlChildDocPartObj) then
        {self.}DocPartObj.Copy(_obj.XmlChildDocPartObj);
    tslassigning := tslassigning_backup;
end;

function SdtPr.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildRPr) then
        {self.}XmlChildRPr.ConvertToPoint();
    if not ifnil({self.}XmlChildId) then
        {self.}XmlChildId.ConvertToPoint();
    if not ifnil({self.}XmlChildDocPartObj) then
        {self.}XmlChildDocPartObj.ConvertToPoint();
end;

function SdtPr.ReadXmlChildRPr(): RPr;
begin
    if tslassigning and (ifnil({self.}XmlChildRPr) or {self.}XmlChildRPr.Removed) then
    begin
        {self.}XmlChildRPr := new RPr(self, {self.}Prefix, "rPr");
        container_.Set({self.}XmlChildRPr);
    end
    return {self.}XmlChildRPr and not {self.}XmlChildRPr.Removed ? {self.}XmlChildRPr : fallback_.XmlChildRPr;
end;

function SdtPr.WriteXmlChildRPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRPr) then
            {self.}RemoveChild({self.}XmlChildRPr);
    end
    else if v is class(RPr) then
    begin
        {self.}XmlChildRPr := v;
        container_.Set({self.}XmlChildRPr);
    end
    else begin
        raise "Invalid assignment: RPr expects RPr or nil";
    end
end;

function SdtPr.ReadXmlChildId(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildId) or {self.}XmlChildId.Removed) then
    begin
        {self.}XmlChildId := new PureWVal(self, {self.}Prefix, "id");
        container_.Set({self.}XmlChildId);
    end
    return {self.}XmlChildId and not {self.}XmlChildId.Removed ? {self.}XmlChildId : fallback_.XmlChildId;
end;

function SdtPr.WriteXmlChildId(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildId) then
            {self.}RemoveChild({self.}XmlChildId);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildId := v;
        container_.Set({self.}XmlChildId);
    end
    else begin
        raise "Invalid assignment: Id expects PureWVal or nil";
    end
end;

function SdtPr.ReadXmlChildDocPartObj(): DocPartObj;
begin
    if tslassigning and (ifnil({self.}XmlChildDocPartObj) or {self.}XmlChildDocPartObj.Removed) then
    begin
        {self.}XmlChildDocPartObj := new DocPartObj(self, {self.}Prefix, "docPartObj");
        container_.Set({self.}XmlChildDocPartObj);
    end
    return {self.}XmlChildDocPartObj and not {self.}XmlChildDocPartObj.Removed ? {self.}XmlChildDocPartObj : fallback_.XmlChildDocPartObj;
end;

function SdtPr.WriteXmlChildDocPartObj(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildDocPartObj) then
            {self.}RemoveChild({self.}XmlChildDocPartObj);
    end
    else if v is class(DocPartObj) then
    begin
        {self.}XmlChildDocPartObj := v;
        container_.Set({self.}XmlChildDocPartObj);
    end
    else begin
        raise "Invalid assignment: DocPartObj expects DocPartObj or nil";
    end
end;

function DocPartObj.Create();overload;
begin
    {self.}Create(nil, "w", "docPartObj");
end;

function DocPartObj.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function DocPartObj.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function DocPartObj.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "docPartGallery": array(0, makeweakref(thisFunction(ReadXmlChildDocPartGallery))),
        pre + "docPartUnique": array(1, makeweakref(thisFunction(ReadXmlChildDocPartUnique))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function DocPartObj.Copy(_obj: DocPartObj);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildDocPartGallery) then
        {self.}DocPartGallery.Copy(_obj.XmlChildDocPartGallery);
    if not ifnil(_obj.XmlChildDocPartUnique) then
        {self.}DocPartUnique.Copy(_obj.XmlChildDocPartUnique);
    tslassigning := tslassigning_backup;
end;

function DocPartObj.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildDocPartGallery) then
        {self.}XmlChildDocPartGallery.ConvertToPoint();
    if not ifnil({self.}XmlChildDocPartUnique) then
        {self.}XmlChildDocPartUnique.ConvertToPoint();
end;

function DocPartObj.ReadXmlChildDocPartGallery(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildDocPartGallery) or {self.}XmlChildDocPartGallery.Removed) then
    begin
        {self.}XmlChildDocPartGallery := new PureWVal(self, {self.}Prefix, "docPartGallery");
        container_.Set({self.}XmlChildDocPartGallery);
    end
    return {self.}XmlChildDocPartGallery and not {self.}XmlChildDocPartGallery.Removed ? {self.}XmlChildDocPartGallery : fallback_.XmlChildDocPartGallery;
end;

function DocPartObj.WriteXmlChildDocPartGallery(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildDocPartGallery) then
            {self.}RemoveChild({self.}XmlChildDocPartGallery);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildDocPartGallery := v;
        container_.Set({self.}XmlChildDocPartGallery);
    end
    else begin
        raise "Invalid assignment: DocPartGallery expects PureWVal or nil";
    end
end;

function DocPartObj.ReadXmlChildDocPartUnique(): PureVal;
begin
    if tslassigning and (ifnil({self.}XmlChildDocPartUnique) or {self.}XmlChildDocPartUnique.Removed) then
    begin
        {self.}XmlChildDocPartUnique := new PureVal(self, {self.}Prefix, "docPartUnique");
        container_.Set({self.}XmlChildDocPartUnique);
    end
    return {self.}XmlChildDocPartUnique and not {self.}XmlChildDocPartUnique.Removed ? {self.}XmlChildDocPartUnique : fallback_.XmlChildDocPartUnique;
end;

function DocPartObj.WriteXmlChildDocPartUnique(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildDocPartUnique) then
            {self.}RemoveChild({self.}XmlChildDocPartUnique);
    end
    else if v is class(PureVal) then
    begin
        {self.}XmlChildDocPartUnique := v;
        container_.Set({self.}XmlChildDocPartUnique);
    end
    else begin
        raise "Invalid assignment: DocPartUnique expects PureVal or nil";
    end
end;

function SdtEndPr.Create();overload;
begin
    {self.}Create(nil, "w", "sdtEndPr");
end;

function SdtEndPr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function SdtEndPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function SdtEndPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "rPr": array(0, makeweakref(thisFunction(ReadXmlChildRPr))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function SdtEndPr.Copy(_obj: SdtEndPr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildRPr) then
        {self.}RPr.Copy(_obj.XmlChildRPr);
    tslassigning := tslassigning_backup;
end;

function SdtEndPr.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildRPr) then
        {self.}XmlChildRPr.ConvertToPoint();
end;

function SdtEndPr.ReadXmlChildRPr(): RPr;
begin
    if tslassigning and (ifnil({self.}XmlChildRPr) or {self.}XmlChildRPr.Removed) then
    begin
        {self.}XmlChildRPr := new RPr(self, {self.}Prefix, "rPr");
        container_.Set({self.}XmlChildRPr);
    end
    return {self.}XmlChildRPr and not {self.}XmlChildRPr.Removed ? {self.}XmlChildRPr : fallback_.XmlChildRPr;
end;

function SdtEndPr.WriteXmlChildRPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRPr) then
            {self.}RemoveChild({self.}XmlChildRPr);
    end
    else if v is class(RPr) then
    begin
        {self.}XmlChildRPr := v;
        container_.Set({self.}XmlChildRPr);
    end
    else begin
        raise "Invalid assignment: RPr expects RPr or nil";
    end
end;

function SdtContent.Create();overload;
begin
    {self.}Create(nil, "w", "sdtContent");
end;

function SdtContent.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function SdtContent.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function SdtContent.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "p": array(0, makeweakref(thisFunction(AppendP))),
        pre + "r": array(1, makeweakref(thisFunction(AppendR))),
        pre + "sdt": array(2, makeweakref(thisFunction(ReadXmlChildSdt))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function SdtContent.Copy(_obj: SdtContent);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildSdt) then
        {self.}Sdt.Copy(_obj.XmlChildSdt);
    tslassigning := tslassigning_backup;
end;

function SdtContent.ConvertToPoint();override;
begin
    elems := {self.}Ps();
    for _,elem in elems do
        elem.ConvertToPoint();
    elems := {self.}Rs();
    for _,elem in elems do
        elem.ConvertToPoint();
    if not ifnil({self.}XmlChildSdt) then
        {self.}XmlChildSdt.ConvertToPoint();
end;

function SdtContent.ReadXmlChildSdt(): Sdt;
begin
    if tslassigning and (ifnil({self.}XmlChildSdt) or {self.}XmlChildSdt.Removed) then
    begin
        {self.}XmlChildSdt := new Sdt(self, {self.}Prefix, "sdt");
        container_.Set({self.}XmlChildSdt);
    end
    return {self.}XmlChildSdt and not {self.}XmlChildSdt.Removed ? {self.}XmlChildSdt : fallback_.XmlChildSdt;
end;

function SdtContent.WriteXmlChildSdt(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildSdt) then
            {self.}RemoveChild({self.}XmlChildSdt);
    end
    else if v is class(Sdt) then
    begin
        {self.}XmlChildSdt := v;
        container_.Set({self.}XmlChildSdt);
    end
    else begin
        raise "Invalid assignment: Sdt expects Sdt or nil";
    end
end;

function SdtContent.ReadPs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "p", ind);
end;

function SdtContent.WritePs(_index: integer; _value: nil_OR_P);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadPs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "p", ind, _value) then
            raise format("Index out of range: Ps[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Ps expects nil or P";
    end
end;

function SdtContent.ReadRs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "r", ind);
end;

function SdtContent.WriteRs(_index: integer; _value: nil_OR_R);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadRs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "r", ind, _value) then
            raise format("Index out of range: Rs[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Rs expects nil or R";
    end
end;

function SdtContent.AddP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Insert(obj);
    return obj;
end;

function SdtContent.AddR(): R;
begin
    obj := new R(self, {self.}Prefix, "r");
    container_.Insert(obj);
    return obj;
end;

function SdtContent.AppendP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Append(obj);
    return obj;
end;

function SdtContent.AppendR(): R;
begin
    obj := new R(self, {self.}Prefix, "r");
    container_.Append(obj);
    return obj;
end;

function SectPr.Create();overload;
begin
    {self.}Create(nil, "w", "sectPr");
end;

function SectPr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function SectPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function SectPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "rsidR": makeweakref(thisFunction(WriteXmlAttrRsidR)),
        pre + "rsidSect": makeweakref(thisFunction(WriteXmlAttrRsidSect)),
    );
    sorted_child_ := array(
        pre + "headerReference": array(0, makeweakref(thisFunction(AppendHeaderReference))),
        pre + "footerReference": array(1, makeweakref(thisFunction(AppendFooterReference))),
        pre + "footnotePr": array(2, makeweakref(thisFunction(ReadXmlChildFootnotePr))),
        pre + "endnotePr": array(3, makeweakref(thisFunction(ReadXmlChildEndnotePr))),
        pre + "type": array(4, makeweakref(thisFunction(ReadXmlChildType))),
        pre + "pgSz": array(5, makeweakref(thisFunction(ReadXmlChildPgSz))),
        pre + "pgMar": array(6, makeweakref(thisFunction(ReadXmlChildPgMar))),
        pre + "pgNumType": array(7, makeweakref(thisFunction(ReadXmlChildPgNumType))),
        pre + "cols": array(8, makeweakref(thisFunction(ReadXmlChildCols))),
        pre + "titlePg": array(9, makeweakref(thisFunction(ReadXmlChildTitlePg))),
        pre + "docGrid": array(10, makeweakref(thisFunction(ReadXmlChildDocGrid))),
        pre + "textDirection": array(11, makeweakref(thisFunction(ReadXmlChildTextDirection))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function SectPr.Copy(_obj: SectPr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.RsidR) then
        {self.}RsidR := _obj.RsidR;
    if not ifnil(_obj.RsidSect) then
        {self.}RsidSect := _obj.RsidSect;
    if not ifnil(_obj.XmlChildFootnotePr) then
        {self.}FootnotePr.Copy(_obj.XmlChildFootnotePr);
    if not ifnil(_obj.XmlChildEndnotePr) then
        {self.}EndnotePr.Copy(_obj.XmlChildEndnotePr);
    if not ifnil(_obj.XmlChildType) then
        {self.}Type.Copy(_obj.XmlChildType);
    if not ifnil(_obj.XmlChildPgSz) then
        {self.}PgSz.Copy(_obj.XmlChildPgSz);
    if not ifnil(_obj.XmlChildPgMar) then
        {self.}PgMar.Copy(_obj.XmlChildPgMar);
    if not ifnil(_obj.XmlChildPgNumType) then
        {self.}PgNumType.Copy(_obj.XmlChildPgNumType);
    if not ifnil(_obj.XmlChildCols) then
        {self.}Cols.Copy(_obj.XmlChildCols);
    if not ifnil(_obj.XmlChildTitlePg) then
        ifnil({self.}XmlChildTitlePg) ? {self.}TitlePg.Copy(_obj.XmlChildTitlePg) : {self.}XmlChildTitlePg.Copy(_obj.XmlChildTitlePg);
    if not ifnil(_obj.XmlChildDocGrid) then
        {self.}DocGrid.Copy(_obj.XmlChildDocGrid);
    if not ifnil(_obj.XmlChildTextDirection) then
        {self.}TextDirection.Copy(_obj.XmlChildTextDirection);
    tslassigning := tslassigning_backup;
end;

function SectPr.ConvertToPoint();override;
begin
    elems := {self.}HeaderReferences();
    for _,elem in elems do
        elem.ConvertToPoint();
    elems := {self.}FooterReferences();
    for _,elem in elems do
        elem.ConvertToPoint();
    if not ifnil({self.}XmlChildFootnotePr) then
        {self.}XmlChildFootnotePr.ConvertToPoint();
    if not ifnil({self.}XmlChildEndnotePr) then
        {self.}XmlChildEndnotePr.ConvertToPoint();
    if not ifnil({self.}XmlChildType) then
        {self.}XmlChildType.ConvertToPoint();
    if not ifnil({self.}XmlChildPgSz) then
        {self.}XmlChildPgSz.ConvertToPoint();
    if not ifnil({self.}XmlChildPgMar) then
        {self.}XmlChildPgMar.ConvertToPoint();
    if not ifnil({self.}XmlChildPgNumType) then
        {self.}XmlChildPgNumType.ConvertToPoint();
    if not ifnil({self.}XmlChildCols) then
        {self.}XmlChildCols.ConvertToPoint();
    if not ifnil({self.}XmlChildDocGrid) then
        {self.}XmlChildDocGrid.ConvertToPoint();
    if not ifnil({self.}XmlChildTextDirection) then
        {self.}XmlChildTextDirection.ConvertToPoint();
end;

function SectPr.ReadXmlAttrRsidR();
begin
    return ifnil({self.}XmlAttrRsidR.Value) ? fallback_.XmlAttrRsidR.Value : {self.}XmlAttrRsidR.Value;
end;

function SectPr.WriteXmlAttrRsidR(_value: any);
begin
    if ifnil({self.}XmlAttrRsidR) then
    begin
        {self.}XmlAttrRsidR := new OpenXmlAttribute({self.}Prefix, "rsidR", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "rsidR" : "rsidR"] := {self.}XmlAttrRsidR;
    end
    {self.}XmlAttrRsidR.Value := _value;
end;

function SectPr.ReadXmlAttrRsidSect();
begin
    return ifnil({self.}XmlAttrRsidSect.Value) ? fallback_.XmlAttrRsidSect.Value : {self.}XmlAttrRsidSect.Value;
end;

function SectPr.WriteXmlAttrRsidSect(_value: any);
begin
    if ifnil({self.}XmlAttrRsidSect) then
    begin
        {self.}XmlAttrRsidSect := new OpenXmlAttribute({self.}Prefix, "rsidSect", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "rsidSect" : "rsidSect"] := {self.}XmlAttrRsidSect;
    end
    {self.}XmlAttrRsidSect.Value := _value;
end;

function SectPr.ReadXmlChildTitlePg();
begin
    if tslassigning and (ifnil({self.}XmlChildTitlePg) or {self.}XmlChildTitlePg.Removed) then
    begin
        {self.}XmlChildTitlePg := new OpenXmlSimpleType(self, {self.}Prefix, "titlePg");
        container_.Set({self.}XmlChildTitlePg);
    end
    return {self.}XmlChildTitlePg and not {self.}XmlChildTitlePg.Removed ? {self.}XmlChildTitlePg : fallback_.XmlChildTitlePg;
end;

function SectPr.WriteXmlChildTitlePg(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildTitlePg) then
            {self.}RemoveChild({self.}XmlChildTitlePg);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildTitlePg := _value;
        container_.Set({self.}XmlChildTitlePg);
    end
    else begin
        raise "Invalid assignment: TitlePg expects nil or OpenXmlSimpleType";
    end
end;

function SectPr.ReadXmlChildFootnotePr(): FootnotePr;
begin
    if tslassigning and (ifnil({self.}XmlChildFootnotePr) or {self.}XmlChildFootnotePr.Removed) then
    begin
        {self.}XmlChildFootnotePr := new FootnotePr(self, {self.}Prefix, "footnotePr");
        container_.Set({self.}XmlChildFootnotePr);
    end
    return {self.}XmlChildFootnotePr and not {self.}XmlChildFootnotePr.Removed ? {self.}XmlChildFootnotePr : fallback_.XmlChildFootnotePr;
end;

function SectPr.WriteXmlChildFootnotePr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildFootnotePr) then
            {self.}RemoveChild({self.}XmlChildFootnotePr);
    end
    else if v is class(FootnotePr) then
    begin
        {self.}XmlChildFootnotePr := v;
        container_.Set({self.}XmlChildFootnotePr);
    end
    else begin
        raise "Invalid assignment: FootnotePr expects FootnotePr or nil";
    end
end;

function SectPr.ReadXmlChildEndnotePr(): EndnotePr;
begin
    if tslassigning and (ifnil({self.}XmlChildEndnotePr) or {self.}XmlChildEndnotePr.Removed) then
    begin
        {self.}XmlChildEndnotePr := new EndnotePr(self, {self.}Prefix, "endnotePr");
        container_.Set({self.}XmlChildEndnotePr);
    end
    return {self.}XmlChildEndnotePr and not {self.}XmlChildEndnotePr.Removed ? {self.}XmlChildEndnotePr : fallback_.XmlChildEndnotePr;
end;

function SectPr.WriteXmlChildEndnotePr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildEndnotePr) then
            {self.}RemoveChild({self.}XmlChildEndnotePr);
    end
    else if v is class(EndnotePr) then
    begin
        {self.}XmlChildEndnotePr := v;
        container_.Set({self.}XmlChildEndnotePr);
    end
    else begin
        raise "Invalid assignment: EndnotePr expects EndnotePr or nil";
    end
end;

function SectPr.ReadXmlChildType(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildType) or {self.}XmlChildType.Removed) then
    begin
        {self.}XmlChildType := new PureWVal(self, {self.}Prefix, "type");
        container_.Set({self.}XmlChildType);
    end
    return {self.}XmlChildType and not {self.}XmlChildType.Removed ? {self.}XmlChildType : fallback_.XmlChildType;
end;

function SectPr.WriteXmlChildType(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildType) then
            {self.}RemoveChild({self.}XmlChildType);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildType := v;
        container_.Set({self.}XmlChildType);
    end
    else begin
        raise "Invalid assignment: Type expects PureWVal or nil";
    end
end;

function SectPr.ReadXmlChildPgSz(): PgSz;
begin
    if tslassigning and (ifnil({self.}XmlChildPgSz) or {self.}XmlChildPgSz.Removed) then
    begin
        {self.}XmlChildPgSz := new PgSz(self, {self.}Prefix, "pgSz");
        container_.Set({self.}XmlChildPgSz);
    end
    return {self.}XmlChildPgSz and not {self.}XmlChildPgSz.Removed ? {self.}XmlChildPgSz : fallback_.XmlChildPgSz;
end;

function SectPr.WriteXmlChildPgSz(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPgSz) then
            {self.}RemoveChild({self.}XmlChildPgSz);
    end
    else if v is class(PgSz) then
    begin
        {self.}XmlChildPgSz := v;
        container_.Set({self.}XmlChildPgSz);
    end
    else begin
        raise "Invalid assignment: PgSz expects PgSz or nil";
    end
end;

function SectPr.ReadXmlChildPgMar(): PgMar;
begin
    if tslassigning and (ifnil({self.}XmlChildPgMar) or {self.}XmlChildPgMar.Removed) then
    begin
        {self.}XmlChildPgMar := new PgMar(self, {self.}Prefix, "pgMar");
        container_.Set({self.}XmlChildPgMar);
    end
    return {self.}XmlChildPgMar and not {self.}XmlChildPgMar.Removed ? {self.}XmlChildPgMar : fallback_.XmlChildPgMar;
end;

function SectPr.WriteXmlChildPgMar(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPgMar) then
            {self.}RemoveChild({self.}XmlChildPgMar);
    end
    else if v is class(PgMar) then
    begin
        {self.}XmlChildPgMar := v;
        container_.Set({self.}XmlChildPgMar);
    end
    else begin
        raise "Invalid assignment: PgMar expects PgMar or nil";
    end
end;

function SectPr.ReadXmlChildPgNumType(): PgNumType;
begin
    if tslassigning and (ifnil({self.}XmlChildPgNumType) or {self.}XmlChildPgNumType.Removed) then
    begin
        {self.}XmlChildPgNumType := new PgNumType(self, {self.}Prefix, "pgNumType");
        container_.Set({self.}XmlChildPgNumType);
    end
    return {self.}XmlChildPgNumType and not {self.}XmlChildPgNumType.Removed ? {self.}XmlChildPgNumType : fallback_.XmlChildPgNumType;
end;

function SectPr.WriteXmlChildPgNumType(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPgNumType) then
            {self.}RemoveChild({self.}XmlChildPgNumType);
    end
    else if v is class(PgNumType) then
    begin
        {self.}XmlChildPgNumType := v;
        container_.Set({self.}XmlChildPgNumType);
    end
    else begin
        raise "Invalid assignment: PgNumType expects PgNumType or nil";
    end
end;

function SectPr.ReadXmlChildCols(): Cols;
begin
    if tslassigning and (ifnil({self.}XmlChildCols) or {self.}XmlChildCols.Removed) then
    begin
        {self.}XmlChildCols := new Cols(self, {self.}Prefix, "cols");
        container_.Set({self.}XmlChildCols);
    end
    return {self.}XmlChildCols and not {self.}XmlChildCols.Removed ? {self.}XmlChildCols : fallback_.XmlChildCols;
end;

function SectPr.WriteXmlChildCols(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildCols) then
            {self.}RemoveChild({self.}XmlChildCols);
    end
    else if v is class(Cols) then
    begin
        {self.}XmlChildCols := v;
        container_.Set({self.}XmlChildCols);
    end
    else begin
        raise "Invalid assignment: Cols expects Cols or nil";
    end
end;

function SectPr.ReadXmlChildDocGrid(): DocGrid;
begin
    if tslassigning and (ifnil({self.}XmlChildDocGrid) or {self.}XmlChildDocGrid.Removed) then
    begin
        {self.}XmlChildDocGrid := new DocGrid(self, {self.}Prefix, "docGrid");
        container_.Set({self.}XmlChildDocGrid);
    end
    return {self.}XmlChildDocGrid and not {self.}XmlChildDocGrid.Removed ? {self.}XmlChildDocGrid : fallback_.XmlChildDocGrid;
end;

function SectPr.WriteXmlChildDocGrid(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildDocGrid) then
            {self.}RemoveChild({self.}XmlChildDocGrid);
    end
    else if v is class(DocGrid) then
    begin
        {self.}XmlChildDocGrid := v;
        container_.Set({self.}XmlChildDocGrid);
    end
    else begin
        raise "Invalid assignment: DocGrid expects DocGrid or nil";
    end
end;

function SectPr.ReadXmlChildTextDirection(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildTextDirection) or {self.}XmlChildTextDirection.Removed) then
    begin
        {self.}XmlChildTextDirection := new PureWVal(self, {self.}Prefix, "textDirection");
        container_.Set({self.}XmlChildTextDirection);
    end
    return {self.}XmlChildTextDirection and not {self.}XmlChildTextDirection.Removed ? {self.}XmlChildTextDirection : fallback_.XmlChildTextDirection;
end;

function SectPr.WriteXmlChildTextDirection(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTextDirection) then
            {self.}RemoveChild({self.}XmlChildTextDirection);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildTextDirection := v;
        container_.Set({self.}XmlChildTextDirection);
    end
    else begin
        raise "Invalid assignment: TextDirection expects PureWVal or nil";
    end
end;

function SectPr.ReadHeaderReferences(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "headerReference", ind);
end;

function SectPr.WriteHeaderReferences(_index: integer; _value: nil_OR_Reference);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadHeaderReferences(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "headerReference", ind, _value) then
            raise format("Index out of range: HeaderReferences[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: HeaderReferences expects nil or Reference";
    end
end;

function SectPr.ReadFooterReferences(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "footerReference", ind);
end;

function SectPr.WriteFooterReferences(_index: integer; _value: nil_OR_Reference);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadFooterReferences(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "footerReference", ind, _value) then
            raise format("Index out of range: FooterReferences[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: FooterReferences expects nil or Reference";
    end
end;

function SectPr.AddHeaderReference(): Reference;
begin
    obj := new Reference(self, {self.}Prefix, "headerReference");
    container_.Insert(obj);
    return obj;
end;

function SectPr.AddFooterReference(): Reference;
begin
    obj := new Reference(self, {self.}Prefix, "footerReference");
    container_.Insert(obj);
    return obj;
end;

function SectPr.AppendHeaderReference(): Reference;
begin
    obj := new Reference(self, {self.}Prefix, "headerReference");
    container_.Append(obj);
    return obj;
end;

function SectPr.AppendFooterReference(): Reference;
begin
    obj := new Reference(self, {self.}Prefix, "footerReference");
    container_.Append(obj);
    return obj;
end;

function Reference.Create();overload;
begin
    {self.}Create(nil, "w", "");
end;

function Reference.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Reference.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Reference.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "type": makeweakref(thisFunction(WriteXmlAttrType)),
        "r:id": makeweakref(thisFunction(WriteXmlAttrId)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Reference.Copy(_obj: Reference);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Type) then
        {self.}Type := _obj.Type;
    if not ifnil(_obj.Id) then
        {self.}Id := _obj.Id;
    tslassigning := tslassigning_backup;
end;

function Reference.ConvertToPoint();override;
begin

end;

function Reference.ReadXmlAttrType();
begin
    return ifnil({self.}XmlAttrType.Value) ? fallback_.XmlAttrType.Value : {self.}XmlAttrType.Value;
end;

function Reference.WriteXmlAttrType(_value: any);
begin
    if ifnil({self.}XmlAttrType) then
    begin
        {self.}XmlAttrType := new OpenXmlAttribute({self.}Prefix, "type", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "type" : "type"] := {self.}XmlAttrType;
    end
    {self.}XmlAttrType.Value := _value;
end;

function Reference.ReadXmlAttrId();
begin
    return ifnil({self.}XmlAttrId.Value) ? fallback_.XmlAttrId.Value : {self.}XmlAttrId.Value;
end;

function Reference.WriteXmlAttrId(_value: any);
begin
    if ifnil({self.}XmlAttrId) then
    begin
        {self.}XmlAttrId := new OpenXmlAttribute("r", "id", nil);
        attributes_["r:id"] := {self.}XmlAttrId;
    end
    {self.}XmlAttrId.Value := _value;
end;

function PgNumType.Create();overload;
begin
    {self.}Create(nil, "w", "pgNumType");
end;

function PgNumType.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function PgNumType.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function PgNumType.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "start": makeweakref(thisFunction(WriteXmlAttrStart)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function PgNumType.Copy(_obj: PgNumType);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Start) then
        {self.}Start := _obj.Start;
    tslassigning := tslassigning_backup;
end;

function PgNumType.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrStart) then
        {self.}Start := TSSafeUnitConverter.ToInt({self.}XmlAttrStart.Value);
end;

function PgNumType.ReadXmlAttrStart();
begin
    return ifnil({self.}XmlAttrStart.Value) ? fallback_.XmlAttrStart.Value : {self.}XmlAttrStart.Value;
end;

function PgNumType.WriteXmlAttrStart(_value: any);
begin
    if ifnil({self.}XmlAttrStart) then
    begin
        {self.}XmlAttrStart := new OpenXmlAttribute({self.}Prefix, "start", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "start" : "start"] := {self.}XmlAttrStart;
    end
    {self.}XmlAttrStart.Value := _value;
end;

function PgSz.Create();overload;
begin
    {self.}Create(nil, "w", "pgSz");
end;

function PgSz.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function PgSz.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function PgSz.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "w": makeweakref(thisFunction(WriteXmlAttrW)),
        pre + "h": makeweakref(thisFunction(WriteXmlAttrH)),
        pre + "orient": makeweakref(thisFunction(WriteXmlAttrOrient)),
        pre + "code": makeweakref(thisFunction(WriteXmlAttrCode)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function PgSz.Copy(_obj: PgSz);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.W) then
        {self.}W := _obj.W;
    if not ifnil(_obj.H) then
        {self.}H := _obj.H;
    if not ifnil(_obj.Orient) then
        {self.}Orient := _obj.Orient;
    if not ifnil(_obj.Code) then
        {self.}Code := _obj.Code;
    tslassigning := tslassigning_backup;
end;

function PgSz.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrW) then
        {self.}W := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrW.Value);
    if not ifnil({self.}XmlAttrH) then
        {self.}H := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrH.Value);
end;

function PgSz.ReadXmlAttrW();
begin
    return ifnil({self.}XmlAttrW.Value) ? fallback_.XmlAttrW.Value : {self.}XmlAttrW.Value;
end;

function PgSz.WriteXmlAttrW(_value: any);
begin
    if ifnil({self.}XmlAttrW) then
    begin
        {self.}XmlAttrW := new OpenXmlAttribute({self.}Prefix, "w", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "w" : "w"] := {self.}XmlAttrW;
    end
    {self.}XmlAttrW.Value := _value;
end;

function PgSz.ReadXmlAttrH();
begin
    return ifnil({self.}XmlAttrH.Value) ? fallback_.XmlAttrH.Value : {self.}XmlAttrH.Value;
end;

function PgSz.WriteXmlAttrH(_value: any);
begin
    if ifnil({self.}XmlAttrH) then
    begin
        {self.}XmlAttrH := new OpenXmlAttribute({self.}Prefix, "h", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "h" : "h"] := {self.}XmlAttrH;
    end
    {self.}XmlAttrH.Value := _value;
end;

function PgSz.ReadXmlAttrOrient();
begin
    return ifnil({self.}XmlAttrOrient.Value) ? fallback_.XmlAttrOrient.Value : {self.}XmlAttrOrient.Value;
end;

function PgSz.WriteXmlAttrOrient(_value: any);
begin
    if ifnil({self.}XmlAttrOrient) then
    begin
        {self.}XmlAttrOrient := new OpenXmlAttribute({self.}Prefix, "orient", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "orient" : "orient"] := {self.}XmlAttrOrient;
    end
    {self.}XmlAttrOrient.Value := _value;
end;

function PgSz.ReadXmlAttrCode();
begin
    return ifnil({self.}XmlAttrCode.Value) ? fallback_.XmlAttrCode.Value : {self.}XmlAttrCode.Value;
end;

function PgSz.WriteXmlAttrCode(_value: any);
begin
    if ifnil({self.}XmlAttrCode) then
    begin
        {self.}XmlAttrCode := new OpenXmlAttribute({self.}Prefix, "code", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "code" : "code"] := {self.}XmlAttrCode;
    end
    {self.}XmlAttrCode.Value := _value;
end;

function PgMar.Create();overload;
begin
    {self.}Create(nil, "w", "pgMar");
end;

function PgMar.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function PgMar.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function PgMar.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "top": makeweakref(thisFunction(WriteXmlAttrTop)),
        pre + "right": makeweakref(thisFunction(WriteXmlAttrRight)),
        pre + "bottom": makeweakref(thisFunction(WriteXmlAttrBottom)),
        pre + "left": makeweakref(thisFunction(WriteXmlAttrLeft)),
        pre + "header": makeweakref(thisFunction(WriteXmlAttrHeader)),
        pre + "footer": makeweakref(thisFunction(WriteXmlAttrFooter)),
        pre + "gutter": makeweakref(thisFunction(WriteXmlAttrGutter)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function PgMar.Copy(_obj: PgMar);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Top) then
        {self.}Top := _obj.Top;
    if not ifnil(_obj.Right) then
        {self.}Right := _obj.Right;
    if not ifnil(_obj.Bottom) then
        {self.}Bottom := _obj.Bottom;
    if not ifnil(_obj.Left) then
        {self.}Left := _obj.Left;
    if not ifnil(_obj.Header) then
        {self.}Header := _obj.Header;
    if not ifnil(_obj.Footer) then
        {self.}Footer := _obj.Footer;
    if not ifnil(_obj.Gutter) then
        {self.}Gutter := _obj.Gutter;
    tslassigning := tslassigning_backup;
end;

function PgMar.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrTop) then
        {self.}Top := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrTop.Value);
    if not ifnil({self.}XmlAttrRight) then
        {self.}Right := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrRight.Value);
    if not ifnil({self.}XmlAttrBottom) then
        {self.}Bottom := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrBottom.Value);
    if not ifnil({self.}XmlAttrLeft) then
        {self.}Left := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrLeft.Value);
    if not ifnil({self.}XmlAttrHeader) then
        {self.}Header := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrHeader.Value);
    if not ifnil({self.}XmlAttrFooter) then
        {self.}Footer := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrFooter.Value);
    if not ifnil({self.}XmlAttrGutter) then
        {self.}Gutter := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrGutter.Value);
end;

function PgMar.ReadXmlAttrTop();
begin
    return ifnil({self.}XmlAttrTop.Value) ? fallback_.XmlAttrTop.Value : {self.}XmlAttrTop.Value;
end;

function PgMar.WriteXmlAttrTop(_value: any);
begin
    if ifnil({self.}XmlAttrTop) then
    begin
        {self.}XmlAttrTop := new OpenXmlAttribute({self.}Prefix, "top", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "top" : "top"] := {self.}XmlAttrTop;
    end
    {self.}XmlAttrTop.Value := _value;
end;

function PgMar.ReadXmlAttrRight();
begin
    return ifnil({self.}XmlAttrRight.Value) ? fallback_.XmlAttrRight.Value : {self.}XmlAttrRight.Value;
end;

function PgMar.WriteXmlAttrRight(_value: any);
begin
    if ifnil({self.}XmlAttrRight) then
    begin
        {self.}XmlAttrRight := new OpenXmlAttribute({self.}Prefix, "right", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "right" : "right"] := {self.}XmlAttrRight;
    end
    {self.}XmlAttrRight.Value := _value;
end;

function PgMar.ReadXmlAttrBottom();
begin
    return ifnil({self.}XmlAttrBottom.Value) ? fallback_.XmlAttrBottom.Value : {self.}XmlAttrBottom.Value;
end;

function PgMar.WriteXmlAttrBottom(_value: any);
begin
    if ifnil({self.}XmlAttrBottom) then
    begin
        {self.}XmlAttrBottom := new OpenXmlAttribute({self.}Prefix, "bottom", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "bottom" : "bottom"] := {self.}XmlAttrBottom;
    end
    {self.}XmlAttrBottom.Value := _value;
end;

function PgMar.ReadXmlAttrLeft();
begin
    return ifnil({self.}XmlAttrLeft.Value) ? fallback_.XmlAttrLeft.Value : {self.}XmlAttrLeft.Value;
end;

function PgMar.WriteXmlAttrLeft(_value: any);
begin
    if ifnil({self.}XmlAttrLeft) then
    begin
        {self.}XmlAttrLeft := new OpenXmlAttribute({self.}Prefix, "left", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "left" : "left"] := {self.}XmlAttrLeft;
    end
    {self.}XmlAttrLeft.Value := _value;
end;

function PgMar.ReadXmlAttrHeader();
begin
    return ifnil({self.}XmlAttrHeader.Value) ? fallback_.XmlAttrHeader.Value : {self.}XmlAttrHeader.Value;
end;

function PgMar.WriteXmlAttrHeader(_value: any);
begin
    if ifnil({self.}XmlAttrHeader) then
    begin
        {self.}XmlAttrHeader := new OpenXmlAttribute({self.}Prefix, "header", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "header" : "header"] := {self.}XmlAttrHeader;
    end
    {self.}XmlAttrHeader.Value := _value;
end;

function PgMar.ReadXmlAttrFooter();
begin
    return ifnil({self.}XmlAttrFooter.Value) ? fallback_.XmlAttrFooter.Value : {self.}XmlAttrFooter.Value;
end;

function PgMar.WriteXmlAttrFooter(_value: any);
begin
    if ifnil({self.}XmlAttrFooter) then
    begin
        {self.}XmlAttrFooter := new OpenXmlAttribute({self.}Prefix, "footer", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "footer" : "footer"] := {self.}XmlAttrFooter;
    end
    {self.}XmlAttrFooter.Value := _value;
end;

function PgMar.ReadXmlAttrGutter();
begin
    return ifnil({self.}XmlAttrGutter.Value) ? fallback_.XmlAttrGutter.Value : {self.}XmlAttrGutter.Value;
end;

function PgMar.WriteXmlAttrGutter(_value: any);
begin
    if ifnil({self.}XmlAttrGutter) then
    begin
        {self.}XmlAttrGutter := new OpenXmlAttribute({self.}Prefix, "gutter", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "gutter" : "gutter"] := {self.}XmlAttrGutter;
    end
    {self.}XmlAttrGutter.Value := _value;
end;

function Cols.Create();overload;
begin
    {self.}Create(nil, "w", "cols");
end;

function Cols.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Cols.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Cols.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "num": makeweakref(thisFunction(WriteXmlAttrNum)),
        pre + "space": makeweakref(thisFunction(WriteXmlAttrSpace)),
        pre + "equalWidth": makeweakref(thisFunction(WriteXmlAttrEqualWidth)),
    );
    sorted_child_ := array(
        pre + "col": array(0, makeweakref(thisFunction(AppendCol))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Cols.Copy(_obj: Cols);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Num) then
        {self.}Num := _obj.Num;
    if not ifnil(_obj.Space) then
        {self.}Space := _obj.Space;
    if not ifnil(_obj.EqualWidth) then
        {self.}EqualWidth := _obj.EqualWidth;
    tslassigning := tslassigning_backup;
end;

function Cols.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrNum) then
        {self.}Num := TSSafeUnitConverter.ToInt({self.}XmlAttrNum.Value);
    if not ifnil({self.}XmlAttrSpace) then
        {self.}Space := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrSpace.Value);
    elems := {self.}Cols();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Cols.ReadXmlAttrNum();
begin
    return ifnil({self.}XmlAttrNum.Value) ? fallback_.XmlAttrNum.Value : {self.}XmlAttrNum.Value;
end;

function Cols.WriteXmlAttrNum(_value: any);
begin
    if ifnil({self.}XmlAttrNum) then
    begin
        {self.}XmlAttrNum := new OpenXmlAttribute({self.}Prefix, "num", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "num" : "num"] := {self.}XmlAttrNum;
    end
    {self.}XmlAttrNum.Value := _value;
end;

function Cols.ReadXmlAttrSpace();
begin
    return ifnil({self.}XmlAttrSpace.Value) ? fallback_.XmlAttrSpace.Value : {self.}XmlAttrSpace.Value;
end;

function Cols.WriteXmlAttrSpace(_value: any);
begin
    if ifnil({self.}XmlAttrSpace) then
    begin
        {self.}XmlAttrSpace := new OpenXmlAttribute({self.}Prefix, "space", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "space" : "space"] := {self.}XmlAttrSpace;
    end
    {self.}XmlAttrSpace.Value := _value;
end;

function Cols.ReadXmlAttrEqualWidth();
begin
    return ifnil({self.}XmlAttrEqualWidth.Value) ? fallback_.XmlAttrEqualWidth.Value : {self.}XmlAttrEqualWidth.Value;
end;

function Cols.WriteXmlAttrEqualWidth(_value: any);
begin
    if ifnil({self.}XmlAttrEqualWidth) then
    begin
        {self.}XmlAttrEqualWidth := new OpenXmlAttribute({self.}Prefix, "equalWidth", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "equalWidth" : "equalWidth"] := {self.}XmlAttrEqualWidth;
    end
    {self.}XmlAttrEqualWidth.Value := _value;
end;

function Cols.ReadCols(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "col", ind);
end;

function Cols.WriteCols(_index: integer; _value: nil_OR_Col);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadCols(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "col", ind, _value) then
            raise format("Index out of range: Cols[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Cols expects nil or Col";
    end
end;

function Cols.AddCol(): Col;
begin
    obj := new Col(self, {self.}Prefix, "col");
    container_.Insert(obj);
    return obj;
end;

function Cols.AppendCol(): Col;
begin
    obj := new Col(self, {self.}Prefix, "col");
    container_.Append(obj);
    return obj;
end;

function Col.Create();overload;
begin
    {self.}Create(nil, "w", "col");
end;

function Col.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Col.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Col.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "w": makeweakref(thisFunction(WriteXmlAttrW)),
        pre + "space": makeweakref(thisFunction(WriteXmlAttrSpace)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Col.Copy(_obj: Col);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.W) then
        {self.}W := _obj.W;
    if not ifnil(_obj.Space) then
        {self.}Space := _obj.Space;
    tslassigning := tslassigning_backup;
end;

function Col.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrW) then
        {self.}W := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrW.Value);
    if not ifnil({self.}XmlAttrSpace) then
        {self.}Space := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrSpace.Value);
end;

function Col.ReadXmlAttrW();
begin
    return ifnil({self.}XmlAttrW.Value) ? fallback_.XmlAttrW.Value : {self.}XmlAttrW.Value;
end;

function Col.WriteXmlAttrW(_value: any);
begin
    if ifnil({self.}XmlAttrW) then
    begin
        {self.}XmlAttrW := new OpenXmlAttribute({self.}Prefix, "w", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "w" : "w"] := {self.}XmlAttrW;
    end
    {self.}XmlAttrW.Value := _value;
end;

function Col.ReadXmlAttrSpace();
begin
    return ifnil({self.}XmlAttrSpace.Value) ? fallback_.XmlAttrSpace.Value : {self.}XmlAttrSpace.Value;
end;

function Col.WriteXmlAttrSpace(_value: any);
begin
    if ifnil({self.}XmlAttrSpace) then
    begin
        {self.}XmlAttrSpace := new OpenXmlAttribute({self.}Prefix, "space", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "space" : "space"] := {self.}XmlAttrSpace;
    end
    {self.}XmlAttrSpace.Value := _value;
end;

function DocGrid.Create();overload;
begin
    {self.}Create(nil, "w", "docGrid");
end;

function DocGrid.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function DocGrid.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function DocGrid.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "type": makeweakref(thisFunction(WriteXmlAttrType)),
        pre + "linePitch": makeweakref(thisFunction(WriteXmlAttrLinePitch)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function DocGrid.Copy(_obj: DocGrid);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Type) then
        {self.}Type := _obj.Type;
    if not ifnil(_obj.LinePitch) then
        {self.}LinePitch := _obj.LinePitch;
    tslassigning := tslassigning_backup;
end;

function DocGrid.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrLinePitch) then
        {self.}LinePitch := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrLinePitch.Value);
end;

function DocGrid.ReadXmlAttrType();
begin
    return ifnil({self.}XmlAttrType.Value) ? fallback_.XmlAttrType.Value : {self.}XmlAttrType.Value;
end;

function DocGrid.WriteXmlAttrType(_value: any);
begin
    if ifnil({self.}XmlAttrType) then
    begin
        {self.}XmlAttrType := new OpenXmlAttribute({self.}Prefix, "type", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "type" : "type"] := {self.}XmlAttrType;
    end
    {self.}XmlAttrType.Value := _value;
end;

function DocGrid.ReadXmlAttrLinePitch();
begin
    return ifnil({self.}XmlAttrLinePitch.Value) ? fallback_.XmlAttrLinePitch.Value : {self.}XmlAttrLinePitch.Value;
end;

function DocGrid.WriteXmlAttrLinePitch(_value: any);
begin
    if ifnil({self.}XmlAttrLinePitch) then
    begin
        {self.}XmlAttrLinePitch := new OpenXmlAttribute({self.}Prefix, "linePitch", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "linePitch" : "linePitch"] := {self.}XmlAttrLinePitch;
    end
    {self.}XmlAttrLinePitch.Value := _value;
end;

function Endnotes.Create();overload;
begin
    {self.}Create(nil, "w", "endnotes");
end;

function Endnotes.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Endnotes.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Endnotes.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "mc:Ignorable": makeweakref(thisFunction(WriteXmlAttrIgnorable)),
    );
    sorted_child_ := array(
        pre + "endnote": array(0, makeweakref(thisFunction(AppendEndnote))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Endnotes.Copy(_obj: Endnotes);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Ignorable) then
        {self.}Ignorable := _obj.Ignorable;
    tslassigning := tslassigning_backup;
end;

function Endnotes.ConvertToPoint();override;
begin
    elems := {self.}Endnotes();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Endnotes.ReadXmlAttrIgnorable();
begin
    return ifnil({self.}XmlAttrIgnorable.Value) ? fallback_.XmlAttrIgnorable.Value : {self.}XmlAttrIgnorable.Value;
end;

function Endnotes.WriteXmlAttrIgnorable(_value: any);
begin
    if ifnil({self.}XmlAttrIgnorable) then
    begin
        {self.}XmlAttrIgnorable := new OpenXmlAttribute("mc", "Ignorable", nil);
        attributes_["mc:Ignorable"] := {self.}XmlAttrIgnorable;
    end
    {self.}XmlAttrIgnorable.Value := _value;
end;

function Endnotes.ReadEndnotes(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "endnote", ind);
end;

function Endnotes.WriteEndnotes(_index: integer; _value: nil_OR_Endnote);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadEndnotes(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "endnote", ind, _value) then
            raise format("Index out of range: Endnotes[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Endnotes expects nil or Endnote";
    end
end;

function Endnotes.AddEndnote(): Endnote;
begin
    obj := new Endnote(self, {self.}Prefix, "endnote");
    container_.Insert(obj);
    return obj;
end;

function Endnotes.AppendEndnote(): Endnote;
begin
    obj := new Endnote(self, {self.}Prefix, "endnote");
    container_.Append(obj);
    return obj;
end;

function Endnote.Create();overload;
begin
    {self.}Create(nil, "w", "endnote");
end;

function Endnote.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Endnote.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Endnote.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "type": makeweakref(thisFunction(WriteXmlAttrType)),
        pre + "id": makeweakref(thisFunction(WriteXmlAttrId)),
    );
    sorted_child_ := array(
        pre + "p": array(0, makeweakref(thisFunction(AppendP))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Endnote.Copy(_obj: Endnote);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Type) then
        {self.}Type := _obj.Type;
    if not ifnil(_obj.Id) then
        {self.}Id := _obj.Id;
    tslassigning := tslassigning_backup;
end;

function Endnote.ConvertToPoint();override;
begin
    elems := {self.}Ps();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Endnote.ReadXmlAttrType();
begin
    return ifnil({self.}XmlAttrType.Value) ? fallback_.XmlAttrType.Value : {self.}XmlAttrType.Value;
end;

function Endnote.WriteXmlAttrType(_value: any);
begin
    if ifnil({self.}XmlAttrType) then
    begin
        {self.}XmlAttrType := new OpenXmlAttribute({self.}Prefix, "type", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "type" : "type"] := {self.}XmlAttrType;
    end
    {self.}XmlAttrType.Value := _value;
end;

function Endnote.ReadXmlAttrId();
begin
    return ifnil({self.}XmlAttrId.Value) ? fallback_.XmlAttrId.Value : {self.}XmlAttrId.Value;
end;

function Endnote.WriteXmlAttrId(_value: any);
begin
    if ifnil({self.}XmlAttrId) then
    begin
        {self.}XmlAttrId := new OpenXmlAttribute({self.}Prefix, "id", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "id" : "id"] := {self.}XmlAttrId;
    end
    {self.}XmlAttrId.Value := _value;
end;

function Endnote.ReadPs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "p", ind);
end;

function Endnote.WritePs(_index: integer; _value: nil_OR_P);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadPs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "p", ind, _value) then
            raise format("Index out of range: Ps[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Ps expects nil or P";
    end
end;

function Endnote.AddP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Insert(obj);
    return obj;
end;

function Endnote.AppendP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Append(obj);
    return obj;
end;

function Footnotes.Create();overload;
begin
    {self.}Create(nil, "w", "footnotes");
end;

function Footnotes.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Footnotes.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Footnotes.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "mc:Ignorable": makeweakref(thisFunction(WriteXmlAttrIgnorable)),
    );
    sorted_child_ := array(
        pre + "footnote": array(0, makeweakref(thisFunction(AppendFootnote))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Footnotes.Copy(_obj: Footnotes);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Ignorable) then
        {self.}Ignorable := _obj.Ignorable;
    tslassigning := tslassigning_backup;
end;

function Footnotes.ConvertToPoint();override;
begin
    elems := {self.}Footnotes();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Footnotes.ReadXmlAttrIgnorable();
begin
    return ifnil({self.}XmlAttrIgnorable.Value) ? fallback_.XmlAttrIgnorable.Value : {self.}XmlAttrIgnorable.Value;
end;

function Footnotes.WriteXmlAttrIgnorable(_value: any);
begin
    if ifnil({self.}XmlAttrIgnorable) then
    begin
        {self.}XmlAttrIgnorable := new OpenXmlAttribute("mc", "Ignorable", nil);
        attributes_["mc:Ignorable"] := {self.}XmlAttrIgnorable;
    end
    {self.}XmlAttrIgnorable.Value := _value;
end;

function Footnotes.ReadFootnotes(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "footnote", ind);
end;

function Footnotes.WriteFootnotes(_index: integer; _value: nil_OR_Footnote);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadFootnotes(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "footnote", ind, _value) then
            raise format("Index out of range: Footnotes[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Footnotes expects nil or Footnote";
    end
end;

function Footnotes.AddFootnote(): Footnote;
begin
    obj := new Footnote(self, {self.}Prefix, "footnote");
    container_.Insert(obj);
    return obj;
end;

function Footnotes.AppendFootnote(): Footnote;
begin
    obj := new Footnote(self, {self.}Prefix, "footnote");
    container_.Append(obj);
    return obj;
end;

function Footnote.Create();overload;
begin
    {self.}Create(nil, "w", "footnote");
end;

function Footnote.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Footnote.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Footnote.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "type": makeweakref(thisFunction(WriteXmlAttrType)),
        pre + "id": makeweakref(thisFunction(WriteXmlAttrId)),
    );
    sorted_child_ := array(
        pre + "p": array(0, makeweakref(thisFunction(AppendP))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Footnote.Copy(_obj: Footnote);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Type) then
        {self.}Type := _obj.Type;
    if not ifnil(_obj.Id) then
        {self.}Id := _obj.Id;
    tslassigning := tslassigning_backup;
end;

function Footnote.ConvertToPoint();override;
begin
    elems := {self.}Ps();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Footnote.ReadXmlAttrType();
begin
    return ifnil({self.}XmlAttrType.Value) ? fallback_.XmlAttrType.Value : {self.}XmlAttrType.Value;
end;

function Footnote.WriteXmlAttrType(_value: any);
begin
    if ifnil({self.}XmlAttrType) then
    begin
        {self.}XmlAttrType := new OpenXmlAttribute({self.}Prefix, "type", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "type" : "type"] := {self.}XmlAttrType;
    end
    {self.}XmlAttrType.Value := _value;
end;

function Footnote.ReadXmlAttrId();
begin
    return ifnil({self.}XmlAttrId.Value) ? fallback_.XmlAttrId.Value : {self.}XmlAttrId.Value;
end;

function Footnote.WriteXmlAttrId(_value: any);
begin
    if ifnil({self.}XmlAttrId) then
    begin
        {self.}XmlAttrId := new OpenXmlAttribute({self.}Prefix, "id", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "id" : "id"] := {self.}XmlAttrId;
    end
    {self.}XmlAttrId.Value := _value;
end;

function Footnote.ReadPs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "p", ind);
end;

function Footnote.WritePs(_index: integer; _value: nil_OR_P);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadPs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "p", ind, _value) then
            raise format("Index out of range: Ps[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Ps expects nil or P";
    end
end;

function Footnote.AddP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Insert(obj);
    return obj;
end;

function Footnote.AppendP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Append(obj);
    return obj;
end;

function Fonts.Create();overload;
begin
    {self.}Create(nil, "w", "fonts");
end;

function Fonts.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Fonts.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Fonts.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "mc:Ignorable": makeweakref(thisFunction(WriteXmlAttrIgnorable)),
    );
    sorted_child_ := array(
        pre + "font": array(0, makeweakref(thisFunction(AppendFont))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Fonts.Copy(_obj: Fonts);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Ignorable) then
        {self.}Ignorable := _obj.Ignorable;
    tslassigning := tslassigning_backup;
end;

function Fonts.ConvertToPoint();override;
begin
    elems := {self.}Fonts();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Fonts.ReadXmlAttrIgnorable();
begin
    return ifnil({self.}XmlAttrIgnorable.Value) ? fallback_.XmlAttrIgnorable.Value : {self.}XmlAttrIgnorable.Value;
end;

function Fonts.WriteXmlAttrIgnorable(_value: any);
begin
    if ifnil({self.}XmlAttrIgnorable) then
    begin
        {self.}XmlAttrIgnorable := new OpenXmlAttribute("mc", "Ignorable", nil);
        attributes_["mc:Ignorable"] := {self.}XmlAttrIgnorable;
    end
    {self.}XmlAttrIgnorable.Value := _value;
end;

function Fonts.ReadFonts(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "font", ind);
end;

function Fonts.WriteFonts(_index: integer; _value: nil_OR_Font);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadFonts(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "font", ind, _value) then
            raise format("Index out of range: Fonts[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Fonts expects nil or Font";
    end
end;

function Fonts.AddFont(): Font;
begin
    obj := new Font(self, {self.}Prefix, "font");
    container_.Insert(obj);
    return obj;
end;

function Fonts.AppendFont(): Font;
begin
    obj := new Font(self, {self.}Prefix, "font");
    container_.Append(obj);
    return obj;
end;

function Font.Create();overload;
begin
    {self.}Create(nil, "w", "font");
end;

function Font.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Font.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Font.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "name": makeweakref(thisFunction(WriteXmlAttrName)),
    );
    sorted_child_ := array(
        pre + "altName": array(0, makeweakref(thisFunction(ReadXmlChildAltName))),
        pre + "panosel": array(1, makeweakref(thisFunction(ReadXmlChildPanosel))),
        pre + "charset": array(2, makeweakref(thisFunction(ReadXmlChildCharset))),
        pre + "family": array(3, makeweakref(thisFunction(ReadXmlChildFamily))),
        pre + "pitch": array(4, makeweakref(thisFunction(ReadXmlChildPitch))),
        pre + "sig": array(5, makeweakref(thisFunction(ReadXmlChildSig))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Font.Copy(_obj: Font);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Name) then
        {self.}Name := _obj.Name;
    if not ifnil(_obj.XmlChildAltName) then
        {self.}AltName.Copy(_obj.XmlChildAltName);
    if not ifnil(_obj.XmlChildPanosel) then
        {self.}Panosel.Copy(_obj.XmlChildPanosel);
    if not ifnil(_obj.XmlChildCharset) then
        {self.}Charset.Copy(_obj.XmlChildCharset);
    if not ifnil(_obj.XmlChildFamily) then
        {self.}Family.Copy(_obj.XmlChildFamily);
    if not ifnil(_obj.XmlChildPitch) then
        {self.}Pitch.Copy(_obj.XmlChildPitch);
    if not ifnil(_obj.XmlChildSig) then
        {self.}Sig.Copy(_obj.XmlChildSig);
    tslassigning := tslassigning_backup;
end;

function Font.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildAltName) then
        {self.}XmlChildAltName.ConvertToPoint();
    if not ifnil({self.}XmlChildPanosel) then
        {self.}XmlChildPanosel.ConvertToPoint();
    if not ifnil({self.}XmlChildCharset) then
        {self.}XmlChildCharset.ConvertToPoint();
    if not ifnil({self.}XmlChildFamily) then
        {self.}XmlChildFamily.ConvertToPoint();
    if not ifnil({self.}XmlChildPitch) then
        {self.}XmlChildPitch.ConvertToPoint();
    if not ifnil({self.}XmlChildSig) then
        {self.}XmlChildSig.ConvertToPoint();
end;

function Font.ReadXmlAttrName();
begin
    return ifnil({self.}XmlAttrName.Value) ? fallback_.XmlAttrName.Value : {self.}XmlAttrName.Value;
end;

function Font.WriteXmlAttrName(_value: any);
begin
    if ifnil({self.}XmlAttrName) then
    begin
        {self.}XmlAttrName := new OpenXmlAttribute({self.}Prefix, "name", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "name" : "name"] := {self.}XmlAttrName;
    end
    {self.}XmlAttrName.Value := _value;
end;

function Font.ReadXmlChildAltName(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildAltName) or {self.}XmlChildAltName.Removed) then
    begin
        {self.}XmlChildAltName := new PureWVal(self, {self.}Prefix, "altName");
        container_.Set({self.}XmlChildAltName);
    end
    return {self.}XmlChildAltName and not {self.}XmlChildAltName.Removed ? {self.}XmlChildAltName : fallback_.XmlChildAltName;
end;

function Font.WriteXmlChildAltName(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildAltName) then
            {self.}RemoveChild({self.}XmlChildAltName);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildAltName := v;
        container_.Set({self.}XmlChildAltName);
    end
    else begin
        raise "Invalid assignment: AltName expects PureWVal or nil";
    end
end;

function Font.ReadXmlChildPanosel(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildPanosel) or {self.}XmlChildPanosel.Removed) then
    begin
        {self.}XmlChildPanosel := new PureWVal(self, {self.}Prefix, "panosel");
        container_.Set({self.}XmlChildPanosel);
    end
    return {self.}XmlChildPanosel and not {self.}XmlChildPanosel.Removed ? {self.}XmlChildPanosel : fallback_.XmlChildPanosel;
end;

function Font.WriteXmlChildPanosel(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPanosel) then
            {self.}RemoveChild({self.}XmlChildPanosel);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildPanosel := v;
        container_.Set({self.}XmlChildPanosel);
    end
    else begin
        raise "Invalid assignment: Panosel expects PureWVal or nil";
    end
end;

function Font.ReadXmlChildCharset(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildCharset) or {self.}XmlChildCharset.Removed) then
    begin
        {self.}XmlChildCharset := new PureWVal(self, {self.}Prefix, "charset");
        container_.Set({self.}XmlChildCharset);
    end
    return {self.}XmlChildCharset and not {self.}XmlChildCharset.Removed ? {self.}XmlChildCharset : fallback_.XmlChildCharset;
end;

function Font.WriteXmlChildCharset(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildCharset) then
            {self.}RemoveChild({self.}XmlChildCharset);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildCharset := v;
        container_.Set({self.}XmlChildCharset);
    end
    else begin
        raise "Invalid assignment: Charset expects PureWVal or nil";
    end
end;

function Font.ReadXmlChildFamily(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildFamily) or {self.}XmlChildFamily.Removed) then
    begin
        {self.}XmlChildFamily := new PureWVal(self, {self.}Prefix, "family");
        container_.Set({self.}XmlChildFamily);
    end
    return {self.}XmlChildFamily and not {self.}XmlChildFamily.Removed ? {self.}XmlChildFamily : fallback_.XmlChildFamily;
end;

function Font.WriteXmlChildFamily(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildFamily) then
            {self.}RemoveChild({self.}XmlChildFamily);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildFamily := v;
        container_.Set({self.}XmlChildFamily);
    end
    else begin
        raise "Invalid assignment: Family expects PureWVal or nil";
    end
end;

function Font.ReadXmlChildPitch(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildPitch) or {self.}XmlChildPitch.Removed) then
    begin
        {self.}XmlChildPitch := new PureWVal(self, {self.}Prefix, "pitch");
        container_.Set({self.}XmlChildPitch);
    end
    return {self.}XmlChildPitch and not {self.}XmlChildPitch.Removed ? {self.}XmlChildPitch : fallback_.XmlChildPitch;
end;

function Font.WriteXmlChildPitch(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPitch) then
            {self.}RemoveChild({self.}XmlChildPitch);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildPitch := v;
        container_.Set({self.}XmlChildPitch);
    end
    else begin
        raise "Invalid assignment: Pitch expects PureWVal or nil";
    end
end;

function Font.ReadXmlChildSig(): Sig;
begin
    if tslassigning and (ifnil({self.}XmlChildSig) or {self.}XmlChildSig.Removed) then
    begin
        {self.}XmlChildSig := new Sig(self, {self.}Prefix, "sig");
        container_.Set({self.}XmlChildSig);
    end
    return {self.}XmlChildSig and not {self.}XmlChildSig.Removed ? {self.}XmlChildSig : fallback_.XmlChildSig;
end;

function Font.WriteXmlChildSig(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildSig) then
            {self.}RemoveChild({self.}XmlChildSig);
    end
    else if v is class(Sig) then
    begin
        {self.}XmlChildSig := v;
        container_.Set({self.}XmlChildSig);
    end
    else begin
        raise "Invalid assignment: Sig expects Sig or nil";
    end
end;

function Sig.Create();overload;
begin
    {self.}Create(nil, "w", "sig");
end;

function Sig.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Sig.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Sig.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "usb0": makeweakref(thisFunction(WriteXmlAttrUsb0)),
        pre + "usb1": makeweakref(thisFunction(WriteXmlAttrUsb1)),
        pre + "usb2": makeweakref(thisFunction(WriteXmlAttrUsb2)),
        pre + "usb3": makeweakref(thisFunction(WriteXmlAttrUsb3)),
        pre + "csb0": makeweakref(thisFunction(WriteXmlAttrCsb0)),
        pre + "csb1": makeweakref(thisFunction(WriteXmlAttrCsb1)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Sig.Copy(_obj: Sig);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Usb0) then
        {self.}Usb0 := _obj.Usb0;
    if not ifnil(_obj.Usb1) then
        {self.}Usb1 := _obj.Usb1;
    if not ifnil(_obj.Usb2) then
        {self.}Usb2 := _obj.Usb2;
    if not ifnil(_obj.Usb3) then
        {self.}Usb3 := _obj.Usb3;
    if not ifnil(_obj.Csb0) then
        {self.}Csb0 := _obj.Csb0;
    if not ifnil(_obj.Csb1) then
        {self.}Csb1 := _obj.Csb1;
    tslassigning := tslassigning_backup;
end;

function Sig.ConvertToPoint();override;
begin

end;

function Sig.ReadXmlAttrUsb0();
begin
    return ifnil({self.}XmlAttrUsb0.Value) ? fallback_.XmlAttrUsb0.Value : {self.}XmlAttrUsb0.Value;
end;

function Sig.WriteXmlAttrUsb0(_value: any);
begin
    if ifnil({self.}XmlAttrUsb0) then
    begin
        {self.}XmlAttrUsb0 := new OpenXmlAttribute({self.}Prefix, "usb0", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "usb0" : "usb0"] := {self.}XmlAttrUsb0;
    end
    {self.}XmlAttrUsb0.Value := _value;
end;

function Sig.ReadXmlAttrUsb1();
begin
    return ifnil({self.}XmlAttrUsb1.Value) ? fallback_.XmlAttrUsb1.Value : {self.}XmlAttrUsb1.Value;
end;

function Sig.WriteXmlAttrUsb1(_value: any);
begin
    if ifnil({self.}XmlAttrUsb1) then
    begin
        {self.}XmlAttrUsb1 := new OpenXmlAttribute({self.}Prefix, "usb1", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "usb1" : "usb1"] := {self.}XmlAttrUsb1;
    end
    {self.}XmlAttrUsb1.Value := _value;
end;

function Sig.ReadXmlAttrUsb2();
begin
    return ifnil({self.}XmlAttrUsb2.Value) ? fallback_.XmlAttrUsb2.Value : {self.}XmlAttrUsb2.Value;
end;

function Sig.WriteXmlAttrUsb2(_value: any);
begin
    if ifnil({self.}XmlAttrUsb2) then
    begin
        {self.}XmlAttrUsb2 := new OpenXmlAttribute({self.}Prefix, "usb2", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "usb2" : "usb2"] := {self.}XmlAttrUsb2;
    end
    {self.}XmlAttrUsb2.Value := _value;
end;

function Sig.ReadXmlAttrUsb3();
begin
    return ifnil({self.}XmlAttrUsb3.Value) ? fallback_.XmlAttrUsb3.Value : {self.}XmlAttrUsb3.Value;
end;

function Sig.WriteXmlAttrUsb3(_value: any);
begin
    if ifnil({self.}XmlAttrUsb3) then
    begin
        {self.}XmlAttrUsb3 := new OpenXmlAttribute({self.}Prefix, "usb3", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "usb3" : "usb3"] := {self.}XmlAttrUsb3;
    end
    {self.}XmlAttrUsb3.Value := _value;
end;

function Sig.ReadXmlAttrCsb0();
begin
    return ifnil({self.}XmlAttrCsb0.Value) ? fallback_.XmlAttrCsb0.Value : {self.}XmlAttrCsb0.Value;
end;

function Sig.WriteXmlAttrCsb0(_value: any);
begin
    if ifnil({self.}XmlAttrCsb0) then
    begin
        {self.}XmlAttrCsb0 := new OpenXmlAttribute({self.}Prefix, "csb0", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "csb0" : "csb0"] := {self.}XmlAttrCsb0;
    end
    {self.}XmlAttrCsb0.Value := _value;
end;

function Sig.ReadXmlAttrCsb1();
begin
    return ifnil({self.}XmlAttrCsb1.Value) ? fallback_.XmlAttrCsb1.Value : {self.}XmlAttrCsb1.Value;
end;

function Sig.WriteXmlAttrCsb1(_value: any);
begin
    if ifnil({self.}XmlAttrCsb1) then
    begin
        {self.}XmlAttrCsb1 := new OpenXmlAttribute({self.}Prefix, "csb1", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "csb1" : "csb1"] := {self.}XmlAttrCsb1;
    end
    {self.}XmlAttrCsb1.Value := _value;
end;

function Settings.Create();overload;
begin
    {self.}Create(nil, "w", "settings");
end;

function Settings.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Settings.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Settings.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "mc:Ignorable": makeweakref(thisFunction(WriteXmlAttrMCIgnorable)),
        "Ignorable": makeweakref(thisFunction(WriteXmlAttrIgnorableN)),
        pre + "Ignorable": makeweakref(thisFunction(WriteXmlAttrIgnorable)),
        "mc:pr": makeweakref(thisFunction(WriteXmlAttrMCPr)),
        pre + "pr": makeweakref(thisFunction(WriteXmlAttrPr)),
        "x:sig": makeweakref(thisFunction(WriteXmlAttrXSig)),
        "mc:sig": makeweakref(thisFunction(WriteXmlAttrMCSig)),
        "sig": makeweakref(thisFunction(WriteXmlAttrSigN)),
    );
    sorted_child_ := array(
        pre + "docId": array(0, makeweakref(thisFunction(ReadXmlChildDocId))),
        "w14:docId": array(1, makeweakref(thisFunction(ReadXmlChildW14DocId))),
        "w15:docId": array(2, makeweakref(thisFunction(ReadXmlChildW15DocId))),
        "w15:chartTrackingRefBased": array(3, makeweakref(thisFunction(ReadXmlChildChartTrackingRefBased))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Settings.Copy(_obj: Settings);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.MCIgnorable) then
        {self.}MCIgnorable := _obj.MCIgnorable;
    if not ifnil(_obj.IgnorableN) then
        {self.}IgnorableN := _obj.IgnorableN;
    if not ifnil(_obj.Ignorable) then
        {self.}Ignorable := _obj.Ignorable;
    if not ifnil(_obj.MCPr) then
        {self.}MCPr := _obj.MCPr;
    if not ifnil(_obj.Pr) then
        {self.}Pr := _obj.Pr;
    if not ifnil(_obj.XSig) then
        {self.}XSig := _obj.XSig;
    if not ifnil(_obj.MCSig) then
        {self.}MCSig := _obj.MCSig;
    if not ifnil(_obj.SigN) then
        {self.}SigN := _obj.SigN;
    if not ifnil(_obj.XmlChildDocId) then
        {self.}DocId.Copy(_obj.XmlChildDocId);
    if not ifnil(_obj.XmlChildW14DocId) then
        {self.}W14DocId.Copy(_obj.XmlChildW14DocId);
    if not ifnil(_obj.XmlChildW15DocId) then
        {self.}W15DocId.Copy(_obj.XmlChildW15DocId);
    if not ifnil(_obj.XmlChildChartTrackingRefBased) then
        ifnil({self.}XmlChildChartTrackingRefBased) ? {self.}ChartTrackingRefBased.Copy(_obj.XmlChildChartTrackingRefBased) : {self.}XmlChildChartTrackingRefBased.Copy(_obj.XmlChildChartTrackingRefBased);
    tslassigning := tslassigning_backup;
end;

function Settings.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildDocId) then
        {self.}XmlChildDocId.ConvertToPoint();
    if not ifnil({self.}XmlChildW14DocId) then
        {self.}XmlChildW14DocId.ConvertToPoint();
    if not ifnil({self.}XmlChildW15DocId) then
        {self.}XmlChildW15DocId.ConvertToPoint();
end;

function Settings.ReadXmlAttrMCIgnorable();
begin
    return ifnil({self.}XmlAttrMCIgnorable.Value) ? fallback_.XmlAttrMCIgnorable.Value : {self.}XmlAttrMCIgnorable.Value;
end;

function Settings.WriteXmlAttrMCIgnorable(_value: any);
begin
    if ifnil({self.}XmlAttrMCIgnorable) then
    begin
        {self.}XmlAttrMCIgnorable := new OpenXmlAttribute("mc", "Ignorable", nil);
        attributes_["mc:Ignorable"] := {self.}XmlAttrMCIgnorable;
    end
    {self.}XmlAttrMCIgnorable.Value := _value;
end;

function Settings.ReadXmlAttrIgnorableN();
begin
    return ifnil({self.}XmlAttrIgnorableN.Value) ? fallback_.XmlAttrIgnorableN.Value : {self.}XmlAttrIgnorableN.Value;
end;

function Settings.WriteXmlAttrIgnorableN(_value: any);
begin
    if ifnil({self.}XmlAttrIgnorableN) then
    begin
        {self.}XmlAttrIgnorableN := new OpenXmlAttribute("", "Ignorable", nil);
        attributes_["Ignorable"] := {self.}XmlAttrIgnorableN;
    end
    {self.}XmlAttrIgnorableN.Value := _value;
end;

function Settings.ReadXmlAttrIgnorable(_ns: string);
begin
    if _ns = "mc" then
        return {self.}ReadXmlAttrMCIgnorable();
    if _ns = "" then
        return {self.}ReadXmlAttrIgnorableN();
    return ifnil({self.}XmlAttrIgnorable.Value) ? fallback_.XmlAttrIgnorable.Value : {self.}XmlAttrIgnorable.Value;
end;

function Settings.WriteXmlAttrIgnorable(_p1: any; _p2: any);
begin
    if realparamcount = 2 then
    begin
        if _p1 = "mc" then
            return {self.}WriteXmlAttrMCIgnorable(_p2);
        if _p1 = "" then
            return {self.}WriteXmlAttrIgnorableN(_p2);
    end
    if ifnil({self.}XmlAttrIgnorable) then
    begin
        {self.}XmlAttrIgnorable := new OpenXmlAttribute({self.}Prefix, "Ignorable", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "Ignorable" : "Ignorable"] := {self.}XmlAttrIgnorable;
    end
    {self.}XmlAttrIgnorable.Value := realparamcount = 1 ? _p1 : _p2;
end;

function Settings.ReadXmlAttrMCPr();
begin
    return ifnil({self.}XmlAttrMCPr.Value) ? fallback_.XmlAttrMCPr.Value : {self.}XmlAttrMCPr.Value;
end;

function Settings.WriteXmlAttrMCPr(_value: any);
begin
    if ifnil({self.}XmlAttrMCPr) then
    begin
        {self.}XmlAttrMCPr := new OpenXmlAttribute("mc", "pr", nil);
        attributes_["mc:pr"] := {self.}XmlAttrMCPr;
    end
    {self.}XmlAttrMCPr.Value := _value;
end;

function Settings.ReadXmlAttrPr(_ns: string);
begin
    if _ns = "mc" then
        return {self.}ReadXmlAttrMCPr();
    return ifnil({self.}XmlAttrPr.Value) ? fallback_.XmlAttrPr.Value : {self.}XmlAttrPr.Value;
end;

function Settings.WriteXmlAttrPr(_p1: any; _p2: any);
begin
    if realparamcount = 2 then
    begin
        if _p1 = "mc" then
            return {self.}WriteXmlAttrMCPr(_p2);
    end
    if ifnil({self.}XmlAttrPr) then
    begin
        {self.}XmlAttrPr := new OpenXmlAttribute({self.}Prefix, "pr", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "pr" : "pr"] := {self.}XmlAttrPr;
    end
    {self.}XmlAttrPr.Value := realparamcount = 1 ? _p1 : _p2;
end;

function Settings.ReadXmlAttrXSig();
begin
    return ifnil({self.}XmlAttrXSig.Value) ? fallback_.XmlAttrXSig.Value : {self.}XmlAttrXSig.Value;
end;

function Settings.WriteXmlAttrXSig(_value: any);
begin
    if ifnil({self.}XmlAttrXSig) then
    begin
        {self.}XmlAttrXSig := new OpenXmlAttribute("x", "sig", nil);
        attributes_["x:sig"] := {self.}XmlAttrXSig;
    end
    {self.}XmlAttrXSig.Value := _value;
end;

function Settings.ReadXmlAttrMCSig();
begin
    return ifnil({self.}XmlAttrMCSig.Value) ? fallback_.XmlAttrMCSig.Value : {self.}XmlAttrMCSig.Value;
end;

function Settings.WriteXmlAttrMCSig(_value: any);
begin
    if ifnil({self.}XmlAttrMCSig) then
    begin
        {self.}XmlAttrMCSig := new OpenXmlAttribute("mc", "sig", nil);
        attributes_["mc:sig"] := {self.}XmlAttrMCSig;
    end
    {self.}XmlAttrMCSig.Value := _value;
end;

function Settings.ReadXmlAttrSigN();
begin
    return ifnil({self.}XmlAttrSigN.Value) ? fallback_.XmlAttrSigN.Value : {self.}XmlAttrSigN.Value;
end;

function Settings.WriteXmlAttrSigN(_value: any);
begin
    if ifnil({self.}XmlAttrSigN) then
    begin
        {self.}XmlAttrSigN := new OpenXmlAttribute("", "sig", nil);
        attributes_["sig"] := {self.}XmlAttrSigN;
    end
    {self.}XmlAttrSigN.Value := _value;
end;

function Settings.ReadXmlChildChartTrackingRefBased();
begin
    if tslassigning and (ifnil({self.}XmlChildChartTrackingRefBased) or {self.}XmlChildChartTrackingRefBased.Removed) then
    begin
        {self.}XmlChildChartTrackingRefBased := new OpenXmlSimpleType(self, "w15", "chartTrackingRefBased");
        container_.Set({self.}XmlChildChartTrackingRefBased);
    end
    return {self.}XmlChildChartTrackingRefBased and not {self.}XmlChildChartTrackingRefBased.Removed ? {self.}XmlChildChartTrackingRefBased : fallback_.XmlChildChartTrackingRefBased;
end;

function Settings.WriteXmlChildChartTrackingRefBased(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildChartTrackingRefBased) then
            {self.}RemoveChild({self.}XmlChildChartTrackingRefBased);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildChartTrackingRefBased := _value;
        container_.Set({self.}XmlChildChartTrackingRefBased);
    end
    else begin
        raise "Invalid assignment: ChartTrackingRefBased expects nil or OpenXmlSimpleType";
    end
end;

function Settings.ReadXmlChildDocId(_ns: string): PureWVal;
begin
    if _ns = "w14" then
        return {self.}ReadXmlChildW14DocId();
    if _ns = "w15" then
        return {self.}ReadXmlChildW15DocId();
    if tslassigning and (ifnil({self.}XmlChildDocId) or {self.}XmlChildDocId.Removed) then
    begin
        {self.}XmlChildDocId := new PureWVal(self, {self.}Prefix, "docId");
        container_.Set({self.}XmlChildDocId);
    end
    return {self.}XmlChildDocId and not {self.}XmlChildDocId.Removed ? {self.}XmlChildDocId : fallback_.XmlChildDocId;
end;

function Settings.WriteXmlChildDocId(_p1: any; _p2: any);
begin
    if realparamcount = 2 then
    begin
        if _p1 = "w14" then
            return {self.}WriteXmlChildW14DocId(_p2);
        if _p1 = "w15" then
            return {self.}WriteXmlChildW15DocId(_p2);
    end
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildDocId) then
            {self.}RemoveChild({self.}XmlChildDocId);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildDocId := v;
        container_.Set({self.}XmlChildDocId);
    end
    else begin
        raise "Invalid assignment: DocId expects PureWVal or nil";
    end
end;

function Settings.ReadXmlChildW14DocId(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildW14DocId) or {self.}XmlChildW14DocId.Removed) then
    begin
        {self.}XmlChildW14DocId := new PureWVal(self, "w14", "docId");
        container_.Set({self.}XmlChildW14DocId);
    end
    return {self.}XmlChildW14DocId and not {self.}XmlChildW14DocId.Removed ? {self.}XmlChildW14DocId : fallback_.XmlChildW14DocId;
end;

function Settings.WriteXmlChildW14DocId(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildW14DocId) then
            {self.}RemoveChild({self.}XmlChildW14DocId);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildW14DocId := v;
        container_.Set({self.}XmlChildW14DocId);
    end
    else begin
        raise "Invalid assignment: DocId expects PureWVal or nil";
    end
end;

function Settings.ReadXmlChildW15DocId(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildW15DocId) or {self.}XmlChildW15DocId.Removed) then
    begin
        {self.}XmlChildW15DocId := new PureWVal(self, "w15", "docId");
        container_.Set({self.}XmlChildW15DocId);
    end
    return {self.}XmlChildW15DocId and not {self.}XmlChildW15DocId.Removed ? {self.}XmlChildW15DocId : fallback_.XmlChildW15DocId;
end;

function Settings.WriteXmlChildW15DocId(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildW15DocId) then
            {self.}RemoveChild({self.}XmlChildW15DocId);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildW15DocId := v;
        container_.Set({self.}XmlChildW15DocId);
    end
    else begin
        raise "Invalid assignment: DocId expects PureWVal or nil";
    end
end;

function Zoom.Create();overload;
begin
    {self.}Create(nil, "w", "zoom");
end;

function Zoom.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Zoom.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Zoom.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "percent": makeweakref(thisFunction(WriteXmlAttrPercent)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Zoom.Copy(_obj: Zoom);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Percent) then
        {self.}Percent := _obj.Percent;
    tslassigning := tslassigning_backup;
end;

function Zoom.ConvertToPoint();override;
begin

end;

function Zoom.ReadXmlAttrPercent();
begin
    return ifnil({self.}XmlAttrPercent.Value) ? fallback_.XmlAttrPercent.Value : {self.}XmlAttrPercent.Value;
end;

function Zoom.WriteXmlAttrPercent(_value: any);
begin
    if ifnil({self.}XmlAttrPercent) then
    begin
        {self.}XmlAttrPercent := new OpenXmlAttribute({self.}Prefix, "percent", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "percent" : "percent"] := {self.}XmlAttrPercent;
    end
    {self.}XmlAttrPercent.Value := _value;
end;

function HdrShapeDefaults.Create();overload;
begin
    {self.}Create(nil, "w", "hdrShapeDefaults");
end;

function HdrShapeDefaults.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function HdrShapeDefaults.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function HdrShapeDefaults.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        "o:shapeDefaults": array(0, makeweakref(thisFunction(ReadXmlChildShapeDefaults))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function HdrShapeDefaults.Copy(_obj: HdrShapeDefaults);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildShapeDefaults) then
        {self.}ShapeDefaults.Copy(_obj.XmlChildShapeDefaults);
    tslassigning := tslassigning_backup;
end;

function HdrShapeDefaults.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildShapeDefaults) then
        {self.}XmlChildShapeDefaults.ConvertToPoint();
end;

function HdrShapeDefaults.ReadXmlChildShapeDefaults(): ShapeDefaults;
begin
    if tslassigning and (ifnil({self.}XmlChildShapeDefaults) or {self.}XmlChildShapeDefaults.Removed) then
    begin
        {self.}XmlChildShapeDefaults := new ShapeDefaults(self, "o", "shapeDefaults");
        container_.Set({self.}XmlChildShapeDefaults);
    end
    return {self.}XmlChildShapeDefaults and not {self.}XmlChildShapeDefaults.Removed ? {self.}XmlChildShapeDefaults : fallback_.XmlChildShapeDefaults;
end;

function HdrShapeDefaults.WriteXmlChildShapeDefaults(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildShapeDefaults) then
            {self.}RemoveChild({self.}XmlChildShapeDefaults);
    end
    else if v is class(ShapeDefaults) then
    begin
        {self.}XmlChildShapeDefaults := v;
        container_.Set({self.}XmlChildShapeDefaults);
    end
    else begin
        raise "Invalid assignment: ShapeDefaults expects ShapeDefaults or nil";
    end
end;

function ShapeDefaults.Create();overload;
begin
    {self.}Create(nil, "o", "shapeDefaults");
end;

function ShapeDefaults.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function ShapeDefaults.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function ShapeDefaults.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "v:ext": makeweakref(thisFunction(WriteXmlAttrExt)),
        "spidmax": makeweakref(thisFunction(WriteXmlAttrSpidmax)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function ShapeDefaults.Copy(_obj: ShapeDefaults);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Ext) then
        {self.}Ext := _obj.Ext;
    if not ifnil(_obj.Spidmax) then
        {self.}Spidmax := _obj.Spidmax;
    tslassigning := tslassigning_backup;
end;

function ShapeDefaults.ConvertToPoint();override;
begin

end;

function ShapeDefaults.ReadXmlAttrExt();
begin
    return ifnil({self.}XmlAttrExt.Value) ? fallback_.XmlAttrExt.Value : {self.}XmlAttrExt.Value;
end;

function ShapeDefaults.WriteXmlAttrExt(_value: any);
begin
    if ifnil({self.}XmlAttrExt) then
    begin
        {self.}XmlAttrExt := new OpenXmlAttribute("v", "ext", nil);
        attributes_["v:ext"] := {self.}XmlAttrExt;
    end
    {self.}XmlAttrExt.Value := _value;
end;

function ShapeDefaults.ReadXmlAttrSpidmax();
begin
    return ifnil({self.}XmlAttrSpidmax.Value) ? fallback_.XmlAttrSpidmax.Value : {self.}XmlAttrSpidmax.Value;
end;

function ShapeDefaults.WriteXmlAttrSpidmax(_value: any);
begin
    if ifnil({self.}XmlAttrSpidmax) then
    begin
        {self.}XmlAttrSpidmax := new OpenXmlAttribute("", "spidmax", nil);
        attributes_["spidmax"] := {self.}XmlAttrSpidmax;
    end
    {self.}XmlAttrSpidmax.Value := _value;
end;

function FootnotePr.Create();overload;
begin
    {self.}Create(nil, "w", "footnotePr");
end;

function FootnotePr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function FootnotePr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function FootnotePr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "pos": array(0, makeweakref(thisFunction(ReadXmlChildPos))),
        pre + "numFmt": array(1, makeweakref(thisFunction(ReadXmlChildNumFmt))),
        pre + "numStart": array(2, makeweakref(thisFunction(ReadXmlChildNumStart))),
        pre + "numRestart": array(3, makeweakref(thisFunction(ReadXmlChildNumRestart))),
        pre + "footnote": array(4, makeweakref(thisFunction(AppendFootnote))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function FootnotePr.Copy(_obj: FootnotePr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildPos) then
        {self.}Pos.Copy(_obj.XmlChildPos);
    if not ifnil(_obj.XmlChildNumFmt) then
        {self.}NumFmt.Copy(_obj.XmlChildNumFmt);
    if not ifnil(_obj.XmlChildNumStart) then
        {self.}NumStart.Copy(_obj.XmlChildNumStart);
    if not ifnil(_obj.XmlChildNumRestart) then
        {self.}NumRestart.Copy(_obj.XmlChildNumRestart);
    tslassigning := tslassigning_backup;
end;

function FootnotePr.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildPos) then
        {self.}XmlChildPos.ConvertToPoint();
    if not ifnil({self.}XmlChildNumFmt) then
        {self.}XmlChildNumFmt.ConvertToPoint();
    if not ifnil({self.}XmlChildNumStart) then
        {self.}XmlChildNumStart.ConvertToPoint();
    if not ifnil({self.}XmlChildNumRestart) then
        {self.}XmlChildNumRestart.ConvertToPoint();
    elems := {self.}Footnotes();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function FootnotePr.ReadXmlChildPos(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildPos) or {self.}XmlChildPos.Removed) then
    begin
        {self.}XmlChildPos := new PureWVal(self, {self.}Prefix, "pos");
        container_.Set({self.}XmlChildPos);
    end
    return {self.}XmlChildPos and not {self.}XmlChildPos.Removed ? {self.}XmlChildPos : fallback_.XmlChildPos;
end;

function FootnotePr.WriteXmlChildPos(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPos) then
            {self.}RemoveChild({self.}XmlChildPos);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildPos := v;
        container_.Set({self.}XmlChildPos);
    end
    else begin
        raise "Invalid assignment: Pos expects PureWVal or nil";
    end
end;

function FootnotePr.ReadXmlChildNumFmt(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildNumFmt) or {self.}XmlChildNumFmt.Removed) then
    begin
        {self.}XmlChildNumFmt := new PureWVal(self, {self.}Prefix, "numFmt");
        container_.Set({self.}XmlChildNumFmt);
    end
    return {self.}XmlChildNumFmt and not {self.}XmlChildNumFmt.Removed ? {self.}XmlChildNumFmt : fallback_.XmlChildNumFmt;
end;

function FootnotePr.WriteXmlChildNumFmt(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildNumFmt) then
            {self.}RemoveChild({self.}XmlChildNumFmt);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildNumFmt := v;
        container_.Set({self.}XmlChildNumFmt);
    end
    else begin
        raise "Invalid assignment: NumFmt expects PureWVal or nil";
    end
end;

function FootnotePr.ReadXmlChildNumStart(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildNumStart) or {self.}XmlChildNumStart.Removed) then
    begin
        {self.}XmlChildNumStart := new PureWVal(self, {self.}Prefix, "numStart");
        container_.Set({self.}XmlChildNumStart);
    end
    return {self.}XmlChildNumStart and not {self.}XmlChildNumStart.Removed ? {self.}XmlChildNumStart : fallback_.XmlChildNumStart;
end;

function FootnotePr.WriteXmlChildNumStart(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildNumStart) then
            {self.}RemoveChild({self.}XmlChildNumStart);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildNumStart := v;
        container_.Set({self.}XmlChildNumStart);
    end
    else begin
        raise "Invalid assignment: NumStart expects PureWVal or nil";
    end
end;

function FootnotePr.ReadXmlChildNumRestart(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildNumRestart) or {self.}XmlChildNumRestart.Removed) then
    begin
        {self.}XmlChildNumRestart := new PureWVal(self, {self.}Prefix, "numRestart");
        container_.Set({self.}XmlChildNumRestart);
    end
    return {self.}XmlChildNumRestart and not {self.}XmlChildNumRestart.Removed ? {self.}XmlChildNumRestart : fallback_.XmlChildNumRestart;
end;

function FootnotePr.WriteXmlChildNumRestart(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildNumRestart) then
            {self.}RemoveChild({self.}XmlChildNumRestart);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildNumRestart := v;
        container_.Set({self.}XmlChildNumRestart);
    end
    else begin
        raise "Invalid assignment: NumRestart expects PureWVal or nil";
    end
end;

function FootnotePr.ReadFootnotes(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "footnote", ind);
end;

function FootnotePr.WriteFootnotes(_index: integer; _value: nil_OR_Footnote);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadFootnotes(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "footnote", ind, _value) then
            raise format("Index out of range: Footnotes[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Footnotes expects nil or Footnote";
    end
end;

function FootnotePr.AddFootnote(): Footnote;
begin
    obj := new Footnote(self, {self.}Prefix, "footnote");
    container_.Insert(obj);
    return obj;
end;

function FootnotePr.AppendFootnote(): Footnote;
begin
    obj := new Footnote(self, {self.}Prefix, "footnote");
    container_.Append(obj);
    return obj;
end;

function EndnotePr.Create();overload;
begin
    {self.}Create(nil, "w", "endnotePr");
end;

function EndnotePr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function EndnotePr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function EndnotePr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "pos": array(0, makeweakref(thisFunction(ReadXmlChildPos))),
        pre + "numFmt": array(1, makeweakref(thisFunction(ReadXmlChildNumFmt))),
        pre + "numStart": array(2, makeweakref(thisFunction(ReadXmlChildNumStart))),
        pre + "numRestart": array(3, makeweakref(thisFunction(ReadXmlChildNumRestart))),
        pre + "footnote": array(4, makeweakref(thisFunction(AppendFootnote))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function EndnotePr.Copy(_obj: EndnotePr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildPos) then
        {self.}Pos.Copy(_obj.XmlChildPos);
    if not ifnil(_obj.XmlChildNumFmt) then
        {self.}NumFmt.Copy(_obj.XmlChildNumFmt);
    if not ifnil(_obj.XmlChildNumStart) then
        {self.}NumStart.Copy(_obj.XmlChildNumStart);
    if not ifnil(_obj.XmlChildNumRestart) then
        {self.}NumRestart.Copy(_obj.XmlChildNumRestart);
    tslassigning := tslassigning_backup;
end;

function EndnotePr.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildPos) then
        {self.}XmlChildPos.ConvertToPoint();
    if not ifnil({self.}XmlChildNumFmt) then
        {self.}XmlChildNumFmt.ConvertToPoint();
    if not ifnil({self.}XmlChildNumStart) then
        {self.}XmlChildNumStart.ConvertToPoint();
    if not ifnil({self.}XmlChildNumRestart) then
        {self.}XmlChildNumRestart.ConvertToPoint();
    elems := {self.}Footnotes();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function EndnotePr.ReadXmlChildPos(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildPos) or {self.}XmlChildPos.Removed) then
    begin
        {self.}XmlChildPos := new PureWVal(self, {self.}Prefix, "pos");
        container_.Set({self.}XmlChildPos);
    end
    return {self.}XmlChildPos and not {self.}XmlChildPos.Removed ? {self.}XmlChildPos : fallback_.XmlChildPos;
end;

function EndnotePr.WriteXmlChildPos(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPos) then
            {self.}RemoveChild({self.}XmlChildPos);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildPos := v;
        container_.Set({self.}XmlChildPos);
    end
    else begin
        raise "Invalid assignment: Pos expects PureWVal or nil";
    end
end;

function EndnotePr.ReadXmlChildNumFmt(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildNumFmt) or {self.}XmlChildNumFmt.Removed) then
    begin
        {self.}XmlChildNumFmt := new PureWVal(self, {self.}Prefix, "numFmt");
        container_.Set({self.}XmlChildNumFmt);
    end
    return {self.}XmlChildNumFmt and not {self.}XmlChildNumFmt.Removed ? {self.}XmlChildNumFmt : fallback_.XmlChildNumFmt;
end;

function EndnotePr.WriteXmlChildNumFmt(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildNumFmt) then
            {self.}RemoveChild({self.}XmlChildNumFmt);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildNumFmt := v;
        container_.Set({self.}XmlChildNumFmt);
    end
    else begin
        raise "Invalid assignment: NumFmt expects PureWVal or nil";
    end
end;

function EndnotePr.ReadXmlChildNumStart(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildNumStart) or {self.}XmlChildNumStart.Removed) then
    begin
        {self.}XmlChildNumStart := new PureWVal(self, {self.}Prefix, "numStart");
        container_.Set({self.}XmlChildNumStart);
    end
    return {self.}XmlChildNumStart and not {self.}XmlChildNumStart.Removed ? {self.}XmlChildNumStart : fallback_.XmlChildNumStart;
end;

function EndnotePr.WriteXmlChildNumStart(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildNumStart) then
            {self.}RemoveChild({self.}XmlChildNumStart);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildNumStart := v;
        container_.Set({self.}XmlChildNumStart);
    end
    else begin
        raise "Invalid assignment: NumStart expects PureWVal or nil";
    end
end;

function EndnotePr.ReadXmlChildNumRestart(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildNumRestart) or {self.}XmlChildNumRestart.Removed) then
    begin
        {self.}XmlChildNumRestart := new PureWVal(self, {self.}Prefix, "numRestart");
        container_.Set({self.}XmlChildNumRestart);
    end
    return {self.}XmlChildNumRestart and not {self.}XmlChildNumRestart.Removed ? {self.}XmlChildNumRestart : fallback_.XmlChildNumRestart;
end;

function EndnotePr.WriteXmlChildNumRestart(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildNumRestart) then
            {self.}RemoveChild({self.}XmlChildNumRestart);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildNumRestart := v;
        container_.Set({self.}XmlChildNumRestart);
    end
    else begin
        raise "Invalid assignment: NumRestart expects PureWVal or nil";
    end
end;

function EndnotePr.ReadFootnotes(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "footnote", ind);
end;

function EndnotePr.WriteFootnotes(_index: integer; _value: nil_OR_Footnote);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadFootnotes(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "footnote", ind, _value) then
            raise format("Index out of range: Footnotes[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Footnotes expects nil or Footnote";
    end
end;

function EndnotePr.AddFootnote(): Footnote;
begin
    obj := new Footnote(self, {self.}Prefix, "footnote");
    container_.Insert(obj);
    return obj;
end;

function EndnotePr.AppendFootnote(): Footnote;
begin
    obj := new Footnote(self, {self.}Prefix, "footnote");
    container_.Append(obj);
    return obj;
end;

function Compat.Create();overload;
begin
    {self.}Create(nil, "w", "compat");
end;

function Compat.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Compat.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Compat.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "spaceForUL": array(0, makeweakref(thisFunction(ReadXmlChildSpaceForUL))),
        pre + "balanceSingleByteDoubleByteWidth": array(1, makeweakref(thisFunction(ReadXmlChildBalanceSingleByteDoubleByteWidth))),
        pre + "doNotLeaveBackslashAlone": array(2, makeweakref(thisFunction(ReadXmlChildDoNotLeaveBackslashAlone))),
        pre + "ulTrailSpace": array(3, makeweakref(thisFunction(ReadXmlChildUlTrailSpace))),
        pre + "doNotExpandShiftReturn": array(4, makeweakref(thisFunction(ReadXmlChildDoNotExpandShiftReturn))),
        pre + "adjustLineHeightInTable": array(5, makeweakref(thisFunction(ReadXmlChildAdjustLineHeightInTable))),
        pre + "useFELayout": array(6, makeweakref(thisFunction(ReadXmlChildUseFELayout))),
        pre + "compatSetting": array(7, makeweakref(thisFunction(AppendCompatSetting))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Compat.Copy(_obj: Compat);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildSpaceForUL) then
        ifnil({self.}XmlChildSpaceForUL) ? {self.}SpaceForUL.Copy(_obj.XmlChildSpaceForUL) : {self.}XmlChildSpaceForUL.Copy(_obj.XmlChildSpaceForUL);
    if not ifnil(_obj.XmlChildBalanceSingleByteDoubleByteWidth) then
        ifnil({self.}XmlChildBalanceSingleByteDoubleByteWidth) ? {self.}BalanceSingleByteDoubleByteWidth.Copy(_obj.XmlChildBalanceSingleByteDoubleByteWidth) : {self.}XmlChildBalanceSingleByteDoubleByteWidth.Copy(_obj.XmlChildBalanceSingleByteDoubleByteWidth);
    if not ifnil(_obj.XmlChildDoNotLeaveBackslashAlone) then
        ifnil({self.}XmlChildDoNotLeaveBackslashAlone) ? {self.}DoNotLeaveBackslashAlone.Copy(_obj.XmlChildDoNotLeaveBackslashAlone) : {self.}XmlChildDoNotLeaveBackslashAlone.Copy(_obj.XmlChildDoNotLeaveBackslashAlone);
    if not ifnil(_obj.XmlChildUlTrailSpace) then
        ifnil({self.}XmlChildUlTrailSpace) ? {self.}UlTrailSpace.Copy(_obj.XmlChildUlTrailSpace) : {self.}XmlChildUlTrailSpace.Copy(_obj.XmlChildUlTrailSpace);
    if not ifnil(_obj.XmlChildDoNotExpandShiftReturn) then
        ifnil({self.}XmlChildDoNotExpandShiftReturn) ? {self.}DoNotExpandShiftReturn.Copy(_obj.XmlChildDoNotExpandShiftReturn) : {self.}XmlChildDoNotExpandShiftReturn.Copy(_obj.XmlChildDoNotExpandShiftReturn);
    if not ifnil(_obj.XmlChildAdjustLineHeightInTable) then
        ifnil({self.}XmlChildAdjustLineHeightInTable) ? {self.}AdjustLineHeightInTable.Copy(_obj.XmlChildAdjustLineHeightInTable) : {self.}XmlChildAdjustLineHeightInTable.Copy(_obj.XmlChildAdjustLineHeightInTable);
    if not ifnil(_obj.XmlChildUseFELayout) then
        ifnil({self.}XmlChildUseFELayout) ? {self.}UseFELayout.Copy(_obj.XmlChildUseFELayout) : {self.}XmlChildUseFELayout.Copy(_obj.XmlChildUseFELayout);
    tslassigning := tslassigning_backup;
end;

function Compat.ConvertToPoint();override;
begin
    elems := {self.}CompatSettings();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Compat.ReadXmlChildSpaceForUL();
begin
    if tslassigning and (ifnil({self.}XmlChildSpaceForUL) or {self.}XmlChildSpaceForUL.Removed) then
    begin
        {self.}XmlChildSpaceForUL := new OpenXmlSimpleType(self, {self.}Prefix, "spaceForUL");
        container_.Set({self.}XmlChildSpaceForUL);
    end
    return {self.}XmlChildSpaceForUL and not {self.}XmlChildSpaceForUL.Removed ? {self.}XmlChildSpaceForUL : fallback_.XmlChildSpaceForUL;
end;

function Compat.WriteXmlChildSpaceForUL(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildSpaceForUL) then
            {self.}RemoveChild({self.}XmlChildSpaceForUL);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildSpaceForUL := _value;
        container_.Set({self.}XmlChildSpaceForUL);
    end
    else begin
        raise "Invalid assignment: SpaceForUL expects nil or OpenXmlSimpleType";
    end
end;

function Compat.ReadXmlChildBalanceSingleByteDoubleByteWidth();
begin
    if tslassigning and (ifnil({self.}XmlChildBalanceSingleByteDoubleByteWidth) or {self.}XmlChildBalanceSingleByteDoubleByteWidth.Removed) then
    begin
        {self.}XmlChildBalanceSingleByteDoubleByteWidth := new OpenXmlSimpleType(self, {self.}Prefix, "balanceSingleByteDoubleByteWidth");
        container_.Set({self.}XmlChildBalanceSingleByteDoubleByteWidth);
    end
    return {self.}XmlChildBalanceSingleByteDoubleByteWidth and not {self.}XmlChildBalanceSingleByteDoubleByteWidth.Removed ? {self.}XmlChildBalanceSingleByteDoubleByteWidth : fallback_.XmlChildBalanceSingleByteDoubleByteWidth;
end;

function Compat.WriteXmlChildBalanceSingleByteDoubleByteWidth(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildBalanceSingleByteDoubleByteWidth) then
            {self.}RemoveChild({self.}XmlChildBalanceSingleByteDoubleByteWidth);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildBalanceSingleByteDoubleByteWidth := _value;
        container_.Set({self.}XmlChildBalanceSingleByteDoubleByteWidth);
    end
    else begin
        raise "Invalid assignment: BalanceSingleByteDoubleByteWidth expects nil or OpenXmlSimpleType";
    end
end;

function Compat.ReadXmlChildDoNotLeaveBackslashAlone();
begin
    if tslassigning and (ifnil({self.}XmlChildDoNotLeaveBackslashAlone) or {self.}XmlChildDoNotLeaveBackslashAlone.Removed) then
    begin
        {self.}XmlChildDoNotLeaveBackslashAlone := new OpenXmlSimpleType(self, {self.}Prefix, "doNotLeaveBackslashAlone");
        container_.Set({self.}XmlChildDoNotLeaveBackslashAlone);
    end
    return {self.}XmlChildDoNotLeaveBackslashAlone and not {self.}XmlChildDoNotLeaveBackslashAlone.Removed ? {self.}XmlChildDoNotLeaveBackslashAlone : fallback_.XmlChildDoNotLeaveBackslashAlone;
end;

function Compat.WriteXmlChildDoNotLeaveBackslashAlone(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildDoNotLeaveBackslashAlone) then
            {self.}RemoveChild({self.}XmlChildDoNotLeaveBackslashAlone);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildDoNotLeaveBackslashAlone := _value;
        container_.Set({self.}XmlChildDoNotLeaveBackslashAlone);
    end
    else begin
        raise "Invalid assignment: DoNotLeaveBackslashAlone expects nil or OpenXmlSimpleType";
    end
end;

function Compat.ReadXmlChildUlTrailSpace();
begin
    if tslassigning and (ifnil({self.}XmlChildUlTrailSpace) or {self.}XmlChildUlTrailSpace.Removed) then
    begin
        {self.}XmlChildUlTrailSpace := new OpenXmlSimpleType(self, {self.}Prefix, "ulTrailSpace");
        container_.Set({self.}XmlChildUlTrailSpace);
    end
    return {self.}XmlChildUlTrailSpace and not {self.}XmlChildUlTrailSpace.Removed ? {self.}XmlChildUlTrailSpace : fallback_.XmlChildUlTrailSpace;
end;

function Compat.WriteXmlChildUlTrailSpace(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildUlTrailSpace) then
            {self.}RemoveChild({self.}XmlChildUlTrailSpace);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildUlTrailSpace := _value;
        container_.Set({self.}XmlChildUlTrailSpace);
    end
    else begin
        raise "Invalid assignment: UlTrailSpace expects nil or OpenXmlSimpleType";
    end
end;

function Compat.ReadXmlChildDoNotExpandShiftReturn();
begin
    if tslassigning and (ifnil({self.}XmlChildDoNotExpandShiftReturn) or {self.}XmlChildDoNotExpandShiftReturn.Removed) then
    begin
        {self.}XmlChildDoNotExpandShiftReturn := new OpenXmlSimpleType(self, {self.}Prefix, "doNotExpandShiftReturn");
        container_.Set({self.}XmlChildDoNotExpandShiftReturn);
    end
    return {self.}XmlChildDoNotExpandShiftReturn and not {self.}XmlChildDoNotExpandShiftReturn.Removed ? {self.}XmlChildDoNotExpandShiftReturn : fallback_.XmlChildDoNotExpandShiftReturn;
end;

function Compat.WriteXmlChildDoNotExpandShiftReturn(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildDoNotExpandShiftReturn) then
            {self.}RemoveChild({self.}XmlChildDoNotExpandShiftReturn);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildDoNotExpandShiftReturn := _value;
        container_.Set({self.}XmlChildDoNotExpandShiftReturn);
    end
    else begin
        raise "Invalid assignment: DoNotExpandShiftReturn expects nil or OpenXmlSimpleType";
    end
end;

function Compat.ReadXmlChildAdjustLineHeightInTable();
begin
    if tslassigning and (ifnil({self.}XmlChildAdjustLineHeightInTable) or {self.}XmlChildAdjustLineHeightInTable.Removed) then
    begin
        {self.}XmlChildAdjustLineHeightInTable := new OpenXmlSimpleType(self, {self.}Prefix, "adjustLineHeightInTable");
        container_.Set({self.}XmlChildAdjustLineHeightInTable);
    end
    return {self.}XmlChildAdjustLineHeightInTable and not {self.}XmlChildAdjustLineHeightInTable.Removed ? {self.}XmlChildAdjustLineHeightInTable : fallback_.XmlChildAdjustLineHeightInTable;
end;

function Compat.WriteXmlChildAdjustLineHeightInTable(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildAdjustLineHeightInTable) then
            {self.}RemoveChild({self.}XmlChildAdjustLineHeightInTable);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildAdjustLineHeightInTable := _value;
        container_.Set({self.}XmlChildAdjustLineHeightInTable);
    end
    else begin
        raise "Invalid assignment: AdjustLineHeightInTable expects nil or OpenXmlSimpleType";
    end
end;

function Compat.ReadXmlChildUseFELayout();
begin
    if tslassigning and (ifnil({self.}XmlChildUseFELayout) or {self.}XmlChildUseFELayout.Removed) then
    begin
        {self.}XmlChildUseFELayout := new OpenXmlSimpleType(self, {self.}Prefix, "useFELayout");
        container_.Set({self.}XmlChildUseFELayout);
    end
    return {self.}XmlChildUseFELayout and not {self.}XmlChildUseFELayout.Removed ? {self.}XmlChildUseFELayout : fallback_.XmlChildUseFELayout;
end;

function Compat.WriteXmlChildUseFELayout(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildUseFELayout) then
            {self.}RemoveChild({self.}XmlChildUseFELayout);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildUseFELayout := _value;
        container_.Set({self.}XmlChildUseFELayout);
    end
    else begin
        raise "Invalid assignment: UseFELayout expects nil or OpenXmlSimpleType";
    end
end;

function Compat.ReadXmlChildCompatSetting();
begin
    if tslassigning and (ifnil({self.}XmlChildCompatSetting) or {self.}XmlChildCompatSetting.Removed) then
    begin
        {self.}XmlChildCompatSetting := new OpenXmlSimpleType(self, {self.}Prefix, "compatSetting");
        container_.Set({self.}XmlChildCompatSetting);
    end
    return {self.}XmlChildCompatSetting and not {self.}XmlChildCompatSetting.Removed ? {self.}XmlChildCompatSetting : fallback_.XmlChildCompatSetting;
end;

function Compat.WriteXmlChildCompatSetting(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildCompatSetting) then
            {self.}RemoveChild({self.}XmlChildCompatSetting);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildCompatSetting := _value;
        container_.Set({self.}XmlChildCompatSetting);
    end
    else begin
        raise "Invalid assignment: CompatSetting expects nil or OpenXmlSimpleType";
    end
end;

function Compat.ReadCompatSettings(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "compatSetting", ind);
end;

function Compat.WriteCompatSettings(_index: integer; _value: nil_OR_CompatSetting);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadCompatSettings(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "compatSetting", ind, _value) then
            raise format("Index out of range: CompatSettings[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: CompatSettings expects nil or CompatSetting";
    end
end;

function Compat.AddCompatSetting(): CompatSetting;
begin
    obj := new CompatSetting(self, {self.}Prefix, "compatSetting");
    container_.Insert(obj);
    return obj;
end;

function Compat.AppendCompatSetting(): CompatSetting;
begin
    obj := new CompatSetting(self, {self.}Prefix, "compatSetting");
    container_.Append(obj);
    return obj;
end;

function CompatSetting.Create();overload;
begin
    {self.}Create(nil, "w", "compatSetting");
end;

function CompatSetting.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function CompatSetting.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function CompatSetting.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "name": makeweakref(thisFunction(WriteXmlAttrName)),
        pre + "uri": makeweakref(thisFunction(WriteXmlAttrUri)),
        pre + "val": makeweakref(thisFunction(WriteXmlAttrVal)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function CompatSetting.Copy(_obj: CompatSetting);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Name) then
        {self.}Name := _obj.Name;
    if not ifnil(_obj.Uri) then
        {self.}Uri := _obj.Uri;
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    tslassigning := tslassigning_backup;
end;

function CompatSetting.ConvertToPoint();override;
begin

end;

function CompatSetting.ReadXmlAttrName();
begin
    return ifnil({self.}XmlAttrName.Value) ? fallback_.XmlAttrName.Value : {self.}XmlAttrName.Value;
end;

function CompatSetting.WriteXmlAttrName(_value: any);
begin
    if ifnil({self.}XmlAttrName) then
    begin
        {self.}XmlAttrName := new OpenXmlAttribute({self.}Prefix, "name", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "name" : "name"] := {self.}XmlAttrName;
    end
    {self.}XmlAttrName.Value := _value;
end;

function CompatSetting.ReadXmlAttrUri();
begin
    return ifnil({self.}XmlAttrUri.Value) ? fallback_.XmlAttrUri.Value : {self.}XmlAttrUri.Value;
end;

function CompatSetting.WriteXmlAttrUri(_value: any);
begin
    if ifnil({self.}XmlAttrUri) then
    begin
        {self.}XmlAttrUri := new OpenXmlAttribute({self.}Prefix, "uri", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "uri" : "uri"] := {self.}XmlAttrUri;
    end
    {self.}XmlAttrUri.Value := _value;
end;

function CompatSetting.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function CompatSetting.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute({self.}Prefix, "val", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "val" : "val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function Rsids.Create();overload;
begin
    {self.}Create(nil, "w", "rsids");
end;

function Rsids.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Rsids.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Rsids.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "rsidRoot": array(0, makeweakref(thisFunction(ReadXmlChildRsidRoot))),
        pre + "rsid": array(1, makeweakref(thisFunction(AppendRsid))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Rsids.Copy(_obj: Rsids);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildRsidRoot) then
        {self.}RsidRoot.Copy(_obj.XmlChildRsidRoot);
    tslassigning := tslassigning_backup;
end;

function Rsids.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildRsidRoot) then
        {self.}XmlChildRsidRoot.ConvertToPoint();
    elems := {self.}Rsids();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Rsids.ReadXmlChildRsidRoot(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildRsidRoot) or {self.}XmlChildRsidRoot.Removed) then
    begin
        {self.}XmlChildRsidRoot := new PureWVal(self, {self.}Prefix, "rsidRoot");
        container_.Set({self.}XmlChildRsidRoot);
    end
    return {self.}XmlChildRsidRoot and not {self.}XmlChildRsidRoot.Removed ? {self.}XmlChildRsidRoot : fallback_.XmlChildRsidRoot;
end;

function Rsids.WriteXmlChildRsidRoot(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRsidRoot) then
            {self.}RemoveChild({self.}XmlChildRsidRoot);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildRsidRoot := v;
        container_.Set({self.}XmlChildRsidRoot);
    end
    else begin
        raise "Invalid assignment: RsidRoot expects PureWVal or nil";
    end
end;

function Rsids.ReadRsids(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "rsid", ind);
end;

function Rsids.WriteRsids(_index: integer; _value: nil_OR_PureWVal);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadRsids(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "rsid", ind, _value) then
            raise format("Index out of range: Rsids[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Rsids expects nil or PureWVal";
    end
end;

function Rsids.AddRsid(): PureWVal;
begin
    obj := new PureWVal(self, {self.}Prefix, "rsid");
    container_.Insert(obj);
    return obj;
end;

function Rsids.AppendRsid(): PureWVal;
begin
    obj := new PureWVal(self, {self.}Prefix, "rsid");
    container_.Append(obj);
    return obj;
end;

function ThemeFontLang.Create();overload;
begin
    {self.}Create(nil, "w", "themeFontLang");
end;

function ThemeFontLang.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function ThemeFontLang.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function ThemeFontLang.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "val": makeweakref(thisFunction(WriteXmlAttrVal)),
        pre + "eastAsia": makeweakref(thisFunction(WriteXmlAttrEastAsia)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function ThemeFontLang.Copy(_obj: ThemeFontLang);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Val) then
        {self.}Val := _obj.Val;
    if not ifnil(_obj.EastAsia) then
        {self.}EastAsia := _obj.EastAsia;
    tslassigning := tslassigning_backup;
end;

function ThemeFontLang.ConvertToPoint();override;
begin

end;

function ThemeFontLang.ReadXmlAttrVal();
begin
    return ifnil({self.}XmlAttrVal.Value) ? fallback_.XmlAttrVal.Value : {self.}XmlAttrVal.Value;
end;

function ThemeFontLang.WriteXmlAttrVal(_value: any);
begin
    if ifnil({self.}XmlAttrVal) then
    begin
        {self.}XmlAttrVal := new OpenXmlAttribute({self.}Prefix, "val", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "val" : "val"] := {self.}XmlAttrVal;
    end
    {self.}XmlAttrVal.Value := _value;
end;

function ThemeFontLang.ReadXmlAttrEastAsia();
begin
    return ifnil({self.}XmlAttrEastAsia.Value) ? fallback_.XmlAttrEastAsia.Value : {self.}XmlAttrEastAsia.Value;
end;

function ThemeFontLang.WriteXmlAttrEastAsia(_value: any);
begin
    if ifnil({self.}XmlAttrEastAsia) then
    begin
        {self.}XmlAttrEastAsia := new OpenXmlAttribute({self.}Prefix, "eastAsia", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "eastAsia" : "eastAsia"] := {self.}XmlAttrEastAsia;
    end
    {self.}XmlAttrEastAsia.Value := _value;
end;

function ClrSchemeMapping.Create();overload;
begin
    {self.}Create(nil, "w", "clrSchemeMapping");
end;

function ClrSchemeMapping.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function ClrSchemeMapping.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function ClrSchemeMapping.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "bg1": makeweakref(thisFunction(WriteXmlAttrBg1)),
        pre + "t1": makeweakref(thisFunction(WriteXmlAttrT1)),
        pre + "bg2": makeweakref(thisFunction(WriteXmlAttrBg2)),
        pre + "t2": makeweakref(thisFunction(WriteXmlAttrT2)),
        pre + "accent1": makeweakref(thisFunction(WriteXmlAttrAccent1)),
        pre + "accent2": makeweakref(thisFunction(WriteXmlAttrAccent2)),
        pre + "accent3": makeweakref(thisFunction(WriteXmlAttrAccent3)),
        pre + "accent4": makeweakref(thisFunction(WriteXmlAttrAccent4)),
        pre + "accent5": makeweakref(thisFunction(WriteXmlAttrAccent5)),
        pre + "accent6": makeweakref(thisFunction(WriteXmlAttrAccent6)),
        pre + "hyperlink": makeweakref(thisFunction(WriteXmlAttrHyperLink)),
        pre + "followedHyperlink": makeweakref(thisFunction(WriteXmlAttrFollowedHyperlink)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function ClrSchemeMapping.Copy(_obj: ClrSchemeMapping);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Bg1) then
        {self.}Bg1 := _obj.Bg1;
    if not ifnil(_obj.T1) then
        {self.}T1 := _obj.T1;
    if not ifnil(_obj.Bg2) then
        {self.}Bg2 := _obj.Bg2;
    if not ifnil(_obj.T2) then
        {self.}T2 := _obj.T2;
    if not ifnil(_obj.Accent1) then
        {self.}Accent1 := _obj.Accent1;
    if not ifnil(_obj.Accent2) then
        {self.}Accent2 := _obj.Accent2;
    if not ifnil(_obj.Accent3) then
        {self.}Accent3 := _obj.Accent3;
    if not ifnil(_obj.Accent4) then
        {self.}Accent4 := _obj.Accent4;
    if not ifnil(_obj.Accent5) then
        {self.}Accent5 := _obj.Accent5;
    if not ifnil(_obj.Accent6) then
        {self.}Accent6 := _obj.Accent6;
    if not ifnil(_obj.HyperLink) then
        {self.}HyperLink := _obj.HyperLink;
    if not ifnil(_obj.FollowedHyperlink) then
        {self.}FollowedHyperlink := _obj.FollowedHyperlink;
    tslassigning := tslassigning_backup;
end;

function ClrSchemeMapping.ConvertToPoint();override;
begin

end;

function ClrSchemeMapping.ReadXmlAttrBg1();
begin
    return ifnil({self.}XmlAttrBg1.Value) ? fallback_.XmlAttrBg1.Value : {self.}XmlAttrBg1.Value;
end;

function ClrSchemeMapping.WriteXmlAttrBg1(_value: any);
begin
    if ifnil({self.}XmlAttrBg1) then
    begin
        {self.}XmlAttrBg1 := new OpenXmlAttribute({self.}Prefix, "bg1", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "bg1" : "bg1"] := {self.}XmlAttrBg1;
    end
    {self.}XmlAttrBg1.Value := _value;
end;

function ClrSchemeMapping.ReadXmlAttrT1();
begin
    return ifnil({self.}XmlAttrT1.Value) ? fallback_.XmlAttrT1.Value : {self.}XmlAttrT1.Value;
end;

function ClrSchemeMapping.WriteXmlAttrT1(_value: any);
begin
    if ifnil({self.}XmlAttrT1) then
    begin
        {self.}XmlAttrT1 := new OpenXmlAttribute({self.}Prefix, "t1", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "t1" : "t1"] := {self.}XmlAttrT1;
    end
    {self.}XmlAttrT1.Value := _value;
end;

function ClrSchemeMapping.ReadXmlAttrBg2();
begin
    return ifnil({self.}XmlAttrBg2.Value) ? fallback_.XmlAttrBg2.Value : {self.}XmlAttrBg2.Value;
end;

function ClrSchemeMapping.WriteXmlAttrBg2(_value: any);
begin
    if ifnil({self.}XmlAttrBg2) then
    begin
        {self.}XmlAttrBg2 := new OpenXmlAttribute({self.}Prefix, "bg2", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "bg2" : "bg2"] := {self.}XmlAttrBg2;
    end
    {self.}XmlAttrBg2.Value := _value;
end;

function ClrSchemeMapping.ReadXmlAttrT2();
begin
    return ifnil({self.}XmlAttrT2.Value) ? fallback_.XmlAttrT2.Value : {self.}XmlAttrT2.Value;
end;

function ClrSchemeMapping.WriteXmlAttrT2(_value: any);
begin
    if ifnil({self.}XmlAttrT2) then
    begin
        {self.}XmlAttrT2 := new OpenXmlAttribute({self.}Prefix, "t2", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "t2" : "t2"] := {self.}XmlAttrT2;
    end
    {self.}XmlAttrT2.Value := _value;
end;

function ClrSchemeMapping.ReadXmlAttrAccent1();
begin
    return ifnil({self.}XmlAttrAccent1.Value) ? fallback_.XmlAttrAccent1.Value : {self.}XmlAttrAccent1.Value;
end;

function ClrSchemeMapping.WriteXmlAttrAccent1(_value: any);
begin
    if ifnil({self.}XmlAttrAccent1) then
    begin
        {self.}XmlAttrAccent1 := new OpenXmlAttribute({self.}Prefix, "accent1", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "accent1" : "accent1"] := {self.}XmlAttrAccent1;
    end
    {self.}XmlAttrAccent1.Value := _value;
end;

function ClrSchemeMapping.ReadXmlAttrAccent2();
begin
    return ifnil({self.}XmlAttrAccent2.Value) ? fallback_.XmlAttrAccent2.Value : {self.}XmlAttrAccent2.Value;
end;

function ClrSchemeMapping.WriteXmlAttrAccent2(_value: any);
begin
    if ifnil({self.}XmlAttrAccent2) then
    begin
        {self.}XmlAttrAccent2 := new OpenXmlAttribute({self.}Prefix, "accent2", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "accent2" : "accent2"] := {self.}XmlAttrAccent2;
    end
    {self.}XmlAttrAccent2.Value := _value;
end;

function ClrSchemeMapping.ReadXmlAttrAccent3();
begin
    return ifnil({self.}XmlAttrAccent3.Value) ? fallback_.XmlAttrAccent3.Value : {self.}XmlAttrAccent3.Value;
end;

function ClrSchemeMapping.WriteXmlAttrAccent3(_value: any);
begin
    if ifnil({self.}XmlAttrAccent3) then
    begin
        {self.}XmlAttrAccent3 := new OpenXmlAttribute({self.}Prefix, "accent3", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "accent3" : "accent3"] := {self.}XmlAttrAccent3;
    end
    {self.}XmlAttrAccent3.Value := _value;
end;

function ClrSchemeMapping.ReadXmlAttrAccent4();
begin
    return ifnil({self.}XmlAttrAccent4.Value) ? fallback_.XmlAttrAccent4.Value : {self.}XmlAttrAccent4.Value;
end;

function ClrSchemeMapping.WriteXmlAttrAccent4(_value: any);
begin
    if ifnil({self.}XmlAttrAccent4) then
    begin
        {self.}XmlAttrAccent4 := new OpenXmlAttribute({self.}Prefix, "accent4", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "accent4" : "accent4"] := {self.}XmlAttrAccent4;
    end
    {self.}XmlAttrAccent4.Value := _value;
end;

function ClrSchemeMapping.ReadXmlAttrAccent5();
begin
    return ifnil({self.}XmlAttrAccent5.Value) ? fallback_.XmlAttrAccent5.Value : {self.}XmlAttrAccent5.Value;
end;

function ClrSchemeMapping.WriteXmlAttrAccent5(_value: any);
begin
    if ifnil({self.}XmlAttrAccent5) then
    begin
        {self.}XmlAttrAccent5 := new OpenXmlAttribute({self.}Prefix, "accent5", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "accent5" : "accent5"] := {self.}XmlAttrAccent5;
    end
    {self.}XmlAttrAccent5.Value := _value;
end;

function ClrSchemeMapping.ReadXmlAttrAccent6();
begin
    return ifnil({self.}XmlAttrAccent6.Value) ? fallback_.XmlAttrAccent6.Value : {self.}XmlAttrAccent6.Value;
end;

function ClrSchemeMapping.WriteXmlAttrAccent6(_value: any);
begin
    if ifnil({self.}XmlAttrAccent6) then
    begin
        {self.}XmlAttrAccent6 := new OpenXmlAttribute({self.}Prefix, "accent6", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "accent6" : "accent6"] := {self.}XmlAttrAccent6;
    end
    {self.}XmlAttrAccent6.Value := _value;
end;

function ClrSchemeMapping.ReadXmlAttrHyperLink();
begin
    return ifnil({self.}XmlAttrHyperLink.Value) ? fallback_.XmlAttrHyperLink.Value : {self.}XmlAttrHyperLink.Value;
end;

function ClrSchemeMapping.WriteXmlAttrHyperLink(_value: any);
begin
    if ifnil({self.}XmlAttrHyperLink) then
    begin
        {self.}XmlAttrHyperLink := new OpenXmlAttribute({self.}Prefix, "hyperlink", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "hyperlink" : "hyperlink"] := {self.}XmlAttrHyperLink;
    end
    {self.}XmlAttrHyperLink.Value := _value;
end;

function ClrSchemeMapping.ReadXmlAttrFollowedHyperlink();
begin
    return ifnil({self.}XmlAttrFollowedHyperlink.Value) ? fallback_.XmlAttrFollowedHyperlink.Value : {self.}XmlAttrFollowedHyperlink.Value;
end;

function ClrSchemeMapping.WriteXmlAttrFollowedHyperlink(_value: any);
begin
    if ifnil({self.}XmlAttrFollowedHyperlink) then
    begin
        {self.}XmlAttrFollowedHyperlink := new OpenXmlAttribute({self.}Prefix, "followedHyperlink", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "followedHyperlink" : "followedHyperlink"] := {self.}XmlAttrFollowedHyperlink;
    end
    {self.}XmlAttrFollowedHyperlink.Value := _value;
end;

function ShapeDefaults2.Create();overload;
begin
    {self.}Create(nil, "w", "shapeDefaults");
end;

function ShapeDefaults2.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function ShapeDefaults2.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function ShapeDefaults2.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        "o:shapeDefaults": array(0, makeweakref(thisFunction(ReadXmlChildShapeDefaults))),
        "o:shapelayout": array(1, makeweakref(thisFunction(ReadXmlChildShapeLayout))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function ShapeDefaults2.Copy(_obj: ShapeDefaults2);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildShapeDefaults) then
        {self.}ShapeDefaults.Copy(_obj.XmlChildShapeDefaults);
    if not ifnil(_obj.XmlChildShapeLayout) then
        {self.}ShapeLayout.Copy(_obj.XmlChildShapeLayout);
    tslassigning := tslassigning_backup;
end;

function ShapeDefaults2.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildShapeDefaults) then
        {self.}XmlChildShapeDefaults.ConvertToPoint();
    if not ifnil({self.}XmlChildShapeLayout) then
        {self.}XmlChildShapeLayout.ConvertToPoint();
end;

function ShapeDefaults2.ReadXmlChildShapeDefaults(): ShapeDefaults;
begin
    if tslassigning and (ifnil({self.}XmlChildShapeDefaults) or {self.}XmlChildShapeDefaults.Removed) then
    begin
        {self.}XmlChildShapeDefaults := new ShapeDefaults(self, "o", "shapeDefaults");
        container_.Set({self.}XmlChildShapeDefaults);
    end
    return {self.}XmlChildShapeDefaults and not {self.}XmlChildShapeDefaults.Removed ? {self.}XmlChildShapeDefaults : fallback_.XmlChildShapeDefaults;
end;

function ShapeDefaults2.WriteXmlChildShapeDefaults(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildShapeDefaults) then
            {self.}RemoveChild({self.}XmlChildShapeDefaults);
    end
    else if v is class(ShapeDefaults) then
    begin
        {self.}XmlChildShapeDefaults := v;
        container_.Set({self.}XmlChildShapeDefaults);
    end
    else begin
        raise "Invalid assignment: ShapeDefaults expects ShapeDefaults or nil";
    end
end;

function ShapeDefaults2.ReadXmlChildShapeLayout(): ShapeLayout;
begin
    if tslassigning and (ifnil({self.}XmlChildShapeLayout) or {self.}XmlChildShapeLayout.Removed) then
    begin
        {self.}XmlChildShapeLayout := new ShapeLayout(self, "o", "shapelayout");
        container_.Set({self.}XmlChildShapeLayout);
    end
    return {self.}XmlChildShapeLayout and not {self.}XmlChildShapeLayout.Removed ? {self.}XmlChildShapeLayout : fallback_.XmlChildShapeLayout;
end;

function ShapeDefaults2.WriteXmlChildShapeLayout(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildShapeLayout) then
            {self.}RemoveChild({self.}XmlChildShapeLayout);
    end
    else if v is class(ShapeLayout) then
    begin
        {self.}XmlChildShapeLayout := v;
        container_.Set({self.}XmlChildShapeLayout);
    end
    else begin
        raise "Invalid assignment: ShapeLayout expects ShapeLayout or nil";
    end
end;

function ShapeLayout.Create();overload;
begin
    {self.}Create(nil, "o", "shapelayout");
end;

function ShapeLayout.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function ShapeLayout.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function ShapeLayout.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "v:ext": makeweakref(thisFunction(WriteXmlAttrExt)),
    );
    sorted_child_ := array(
        pre + "idmap": array(0, makeweakref(thisFunction(ReadXmlChildIdMap))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function ShapeLayout.Copy(_obj: ShapeLayout);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Ext) then
        {self.}Ext := _obj.Ext;
    if not ifnil(_obj.XmlChildIdMap) then
        {self.}IdMap.Copy(_obj.XmlChildIdMap);
    tslassigning := tslassigning_backup;
end;

function ShapeLayout.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildIdMap) then
        {self.}XmlChildIdMap.ConvertToPoint();
end;

function ShapeLayout.ReadXmlAttrExt();
begin
    return ifnil({self.}XmlAttrExt.Value) ? fallback_.XmlAttrExt.Value : {self.}XmlAttrExt.Value;
end;

function ShapeLayout.WriteXmlAttrExt(_value: any);
begin
    if ifnil({self.}XmlAttrExt) then
    begin
        {self.}XmlAttrExt := new OpenXmlAttribute("v", "ext", nil);
        attributes_["v:ext"] := {self.}XmlAttrExt;
    end
    {self.}XmlAttrExt.Value := _value;
end;

function ShapeLayout.ReadXmlChildIdMap(): IdMap;
begin
    if tslassigning and (ifnil({self.}XmlChildIdMap) or {self.}XmlChildIdMap.Removed) then
    begin
        {self.}XmlChildIdMap := new IdMap(self, {self.}Prefix, "idmap");
        container_.Set({self.}XmlChildIdMap);
    end
    return {self.}XmlChildIdMap and not {self.}XmlChildIdMap.Removed ? {self.}XmlChildIdMap : fallback_.XmlChildIdMap;
end;

function ShapeLayout.WriteXmlChildIdMap(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildIdMap) then
            {self.}RemoveChild({self.}XmlChildIdMap);
    end
    else if v is class(IdMap) then
    begin
        {self.}XmlChildIdMap := v;
        container_.Set({self.}XmlChildIdMap);
    end
    else begin
        raise "Invalid assignment: IdMap expects IdMap or nil";
    end
end;

function IdMap.Create();overload;
begin
    {self.}Create(nil, "o", "idmap");
end;

function IdMap.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function IdMap.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function IdMap.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "v:ext": makeweakref(thisFunction(WriteXmlAttrExt)),
        "data": makeweakref(thisFunction(WriteXmlAttrData)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function IdMap.Copy(_obj: IdMap);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Ext) then
        {self.}Ext := _obj.Ext;
    if not ifnil(_obj.Data) then
        {self.}Data := _obj.Data;
    tslassigning := tslassigning_backup;
end;

function IdMap.ConvertToPoint();override;
begin

end;

function IdMap.ReadXmlAttrExt();
begin
    return ifnil({self.}XmlAttrExt.Value) ? fallback_.XmlAttrExt.Value : {self.}XmlAttrExt.Value;
end;

function IdMap.WriteXmlAttrExt(_value: any);
begin
    if ifnil({self.}XmlAttrExt) then
    begin
        {self.}XmlAttrExt := new OpenXmlAttribute("v", "ext", nil);
        attributes_["v:ext"] := {self.}XmlAttrExt;
    end
    {self.}XmlAttrExt.Value := _value;
end;

function IdMap.ReadXmlAttrData();
begin
    return ifnil({self.}XmlAttrData.Value) ? fallback_.XmlAttrData.Value : {self.}XmlAttrData.Value;
end;

function IdMap.WriteXmlAttrData(_value: any);
begin
    if ifnil({self.}XmlAttrData) then
    begin
        {self.}XmlAttrData := new OpenXmlAttribute("", "data", nil);
        attributes_["data"] := {self.}XmlAttrData;
    end
    {self.}XmlAttrData.Value := _value;
end;

function Styles.Create();overload;
begin
    {self.}Create(nil, "w", "styles");
end;

function Styles.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Styles.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Styles.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "mc:Ignorable": makeweakref(thisFunction(WriteXmlAttrIgnorable)),
    );
    sorted_child_ := array(
        pre + "docDefaults": array(0, makeweakref(thisFunction(ReadXmlChildDocDefaults))),
        pre + "latenStyles": array(1, makeweakref(thisFunction(ReadXmlChildLatenStyles))),
        pre + "style": array(2, makeweakref(thisFunction(AppendStyle))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Styles.Copy(_obj: Styles);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Ignorable) then
        {self.}Ignorable := _obj.Ignorable;
    if not ifnil(_obj.XmlChildDocDefaults) then
        {self.}DocDefaults.Copy(_obj.XmlChildDocDefaults);
    if not ifnil(_obj.XmlChildLatenStyles) then
        {self.}LatenStyles.Copy(_obj.XmlChildLatenStyles);
    tslassigning := tslassigning_backup;
end;

function Styles.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildDocDefaults) then
        {self.}XmlChildDocDefaults.ConvertToPoint();
    if not ifnil({self.}XmlChildLatenStyles) then
        {self.}XmlChildLatenStyles.ConvertToPoint();
    elems := {self.}Styles();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Styles.ReadXmlAttrIgnorable();
begin
    return ifnil({self.}XmlAttrIgnorable.Value) ? fallback_.XmlAttrIgnorable.Value : {self.}XmlAttrIgnorable.Value;
end;

function Styles.WriteXmlAttrIgnorable(_value: any);
begin
    if ifnil({self.}XmlAttrIgnorable) then
    begin
        {self.}XmlAttrIgnorable := new OpenXmlAttribute("mc", "Ignorable", nil);
        attributes_["mc:Ignorable"] := {self.}XmlAttrIgnorable;
    end
    {self.}XmlAttrIgnorable.Value := _value;
end;

function Styles.ReadXmlChildDocDefaults(): DocDefaults;
begin
    if tslassigning and (ifnil({self.}XmlChildDocDefaults) or {self.}XmlChildDocDefaults.Removed) then
    begin
        {self.}XmlChildDocDefaults := new DocDefaults(self, {self.}Prefix, "docDefaults");
        container_.Set({self.}XmlChildDocDefaults);
    end
    return {self.}XmlChildDocDefaults and not {self.}XmlChildDocDefaults.Removed ? {self.}XmlChildDocDefaults : fallback_.XmlChildDocDefaults;
end;

function Styles.WriteXmlChildDocDefaults(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildDocDefaults) then
            {self.}RemoveChild({self.}XmlChildDocDefaults);
    end
    else if v is class(DocDefaults) then
    begin
        {self.}XmlChildDocDefaults := v;
        container_.Set({self.}XmlChildDocDefaults);
    end
    else begin
        raise "Invalid assignment: DocDefaults expects DocDefaults or nil";
    end
end;

function Styles.ReadXmlChildLatenStyles(): LatenStyles;
begin
    if tslassigning and (ifnil({self.}XmlChildLatenStyles) or {self.}XmlChildLatenStyles.Removed) then
    begin
        {self.}XmlChildLatenStyles := new LatenStyles(self, {self.}Prefix, "latenStyles");
        container_.Set({self.}XmlChildLatenStyles);
    end
    return {self.}XmlChildLatenStyles and not {self.}XmlChildLatenStyles.Removed ? {self.}XmlChildLatenStyles : fallback_.XmlChildLatenStyles;
end;

function Styles.WriteXmlChildLatenStyles(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildLatenStyles) then
            {self.}RemoveChild({self.}XmlChildLatenStyles);
    end
    else if v is class(LatenStyles) then
    begin
        {self.}XmlChildLatenStyles := v;
        container_.Set({self.}XmlChildLatenStyles);
    end
    else begin
        raise "Invalid assignment: LatenStyles expects LatenStyles or nil";
    end
end;

function Styles.ReadStyles(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "style", ind);
end;

function Styles.WriteStyles(_index: integer; _value: nil_OR_Style);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadStyles(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "style", ind, _value) then
            raise format("Index out of range: Styles[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Styles expects nil or Style";
    end
end;

function Styles.AddStyle(): Style;
begin
    obj := new Style(self, {self.}Prefix, "style");
    container_.Insert(obj);
    return obj;
end;

function Styles.AppendStyle(): Style;
begin
    obj := new Style(self, {self.}Prefix, "style");
    container_.Append(obj);
    return obj;
end;

function DocDefaults.Create();overload;
begin
    {self.}Create(nil, "w", "docDefaults");
end;

function DocDefaults.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function DocDefaults.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function DocDefaults.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "rPrDefault": array(0, makeweakref(thisFunction(ReadXmlChildRPrDefault))),
        pre + "pPrDefault": array(1, makeweakref(thisFunction(ReadXmlChildPPrDefault))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function DocDefaults.Copy(_obj: DocDefaults);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildRPrDefault) then
        {self.}RPrDefault.Copy(_obj.XmlChildRPrDefault);
    if not ifnil(_obj.XmlChildPPrDefault) then
        {self.}PPrDefault.Copy(_obj.XmlChildPPrDefault);
    tslassigning := tslassigning_backup;
end;

function DocDefaults.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildRPrDefault) then
        {self.}XmlChildRPrDefault.ConvertToPoint();
    if not ifnil({self.}XmlChildPPrDefault) then
        {self.}XmlChildPPrDefault.ConvertToPoint();
end;

function DocDefaults.ReadXmlChildRPrDefault(): RPrDefault;
begin
    if tslassigning and (ifnil({self.}XmlChildRPrDefault) or {self.}XmlChildRPrDefault.Removed) then
    begin
        {self.}XmlChildRPrDefault := new RPrDefault(self, {self.}Prefix, "rPrDefault");
        container_.Set({self.}XmlChildRPrDefault);
    end
    return {self.}XmlChildRPrDefault and not {self.}XmlChildRPrDefault.Removed ? {self.}XmlChildRPrDefault : fallback_.XmlChildRPrDefault;
end;

function DocDefaults.WriteXmlChildRPrDefault(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRPrDefault) then
            {self.}RemoveChild({self.}XmlChildRPrDefault);
    end
    else if v is class(RPrDefault) then
    begin
        {self.}XmlChildRPrDefault := v;
        container_.Set({self.}XmlChildRPrDefault);
    end
    else begin
        raise "Invalid assignment: RPrDefault expects RPrDefault or nil";
    end
end;

function DocDefaults.ReadXmlChildPPrDefault(): PPrDefault;
begin
    if tslassigning and (ifnil({self.}XmlChildPPrDefault) or {self.}XmlChildPPrDefault.Removed) then
    begin
        {self.}XmlChildPPrDefault := new PPrDefault(self, {self.}Prefix, "pPrDefault");
        container_.Set({self.}XmlChildPPrDefault);
    end
    return {self.}XmlChildPPrDefault and not {self.}XmlChildPPrDefault.Removed ? {self.}XmlChildPPrDefault : fallback_.XmlChildPPrDefault;
end;

function DocDefaults.WriteXmlChildPPrDefault(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPPrDefault) then
            {self.}RemoveChild({self.}XmlChildPPrDefault);
    end
    else if v is class(PPrDefault) then
    begin
        {self.}XmlChildPPrDefault := v;
        container_.Set({self.}XmlChildPPrDefault);
    end
    else begin
        raise "Invalid assignment: PPrDefault expects PPrDefault or nil";
    end
end;

function RPrDefault.Create();overload;
begin
    {self.}Create(nil, "w", "rPrDefault");
end;

function RPrDefault.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function RPrDefault.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function RPrDefault.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "rPr": array(0, makeweakref(thisFunction(ReadXmlChildRPr))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function RPrDefault.Copy(_obj: RPrDefault);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildRPr) then
        {self.}RPr.Copy(_obj.XmlChildRPr);
    tslassigning := tslassigning_backup;
end;

function RPrDefault.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildRPr) then
        {self.}XmlChildRPr.ConvertToPoint();
end;

function RPrDefault.ReadXmlChildRPr(): RPr;
begin
    if tslassigning and (ifnil({self.}XmlChildRPr) or {self.}XmlChildRPr.Removed) then
    begin
        {self.}XmlChildRPr := new RPr(self, {self.}Prefix, "rPr");
        container_.Set({self.}XmlChildRPr);
    end
    return {self.}XmlChildRPr and not {self.}XmlChildRPr.Removed ? {self.}XmlChildRPr : fallback_.XmlChildRPr;
end;

function RPrDefault.WriteXmlChildRPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRPr) then
            {self.}RemoveChild({self.}XmlChildRPr);
    end
    else if v is class(RPr) then
    begin
        {self.}XmlChildRPr := v;
        container_.Set({self.}XmlChildRPr);
    end
    else begin
        raise "Invalid assignment: RPr expects RPr or nil";
    end
end;

function PPrDefault.Create();overload;
begin
    {self.}Create(nil, "w", "pPrDefault");
end;

function PPrDefault.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function PPrDefault.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function PPrDefault.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "pPr": array(0, makeweakref(thisFunction(ReadXmlChildPPr))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function PPrDefault.Copy(_obj: PPrDefault);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildPPr) then
        {self.}PPr.Copy(_obj.XmlChildPPr);
    tslassigning := tslassigning_backup;
end;

function PPrDefault.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildPPr) then
        {self.}XmlChildPPr.ConvertToPoint();
end;

function PPrDefault.ReadXmlChildPPr(): PPr;
begin
    if tslassigning and (ifnil({self.}XmlChildPPr) or {self.}XmlChildPPr.Removed) then
    begin
        {self.}XmlChildPPr := new PPr(self, {self.}Prefix, "pPr");
        container_.Set({self.}XmlChildPPr);
    end
    return {self.}XmlChildPPr and not {self.}XmlChildPPr.Removed ? {self.}XmlChildPPr : fallback_.XmlChildPPr;
end;

function PPrDefault.WriteXmlChildPPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPPr) then
            {self.}RemoveChild({self.}XmlChildPPr);
    end
    else if v is class(PPr) then
    begin
        {self.}XmlChildPPr := v;
        container_.Set({self.}XmlChildPPr);
    end
    else begin
        raise "Invalid assignment: PPr expects PPr or nil";
    end
end;

function LatenStyles.Create();overload;
begin
    {self.}Create(nil, "w", "latenStyles");
end;

function LatenStyles.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function LatenStyles.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function LatenStyles.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "defLickedState": makeweakref(thisFunction(WriteXmlAttrDefLickedState)),
        pre + "defUIPriority": makeweakref(thisFunction(WriteXmlAttrDefUIPriority)),
        pre + "defSemiHidden": makeweakref(thisFunction(WriteXmlAttrDefSemiHidden)),
        pre + "defUnhideWhenUsed": makeweakref(thisFunction(WriteXmlAttrDefUnhideWhenUsed)),
        pre + "defQFormat": makeweakref(thisFunction(WriteXmlAttrDefQFormat)),
        pre + "count": makeweakref(thisFunction(WriteXmlAttrCount)),
    );
    sorted_child_ := array(
        pre + "lsdException": array(0, makeweakref(thisFunction(AppendLsdException))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function LatenStyles.Copy(_obj: LatenStyles);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.DefLickedState) then
        {self.}DefLickedState := _obj.DefLickedState;
    if not ifnil(_obj.DefUIPriority) then
        {self.}DefUIPriority := _obj.DefUIPriority;
    if not ifnil(_obj.DefSemiHidden) then
        {self.}DefSemiHidden := _obj.DefSemiHidden;
    if not ifnil(_obj.DefUnhideWhenUsed) then
        {self.}DefUnhideWhenUsed := _obj.DefUnhideWhenUsed;
    if not ifnil(_obj.DefQFormat) then
        {self.}DefQFormat := _obj.DefQFormat;
    if not ifnil(_obj.Count) then
        {self.}Count := _obj.Count;
    tslassigning := tslassigning_backup;
end;

function LatenStyles.ConvertToPoint();override;
begin
    elems := {self.}LsdExceptions();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function LatenStyles.ReadXmlAttrDefLickedState();
begin
    return ifnil({self.}XmlAttrDefLickedState.Value) ? fallback_.XmlAttrDefLickedState.Value : {self.}XmlAttrDefLickedState.Value;
end;

function LatenStyles.WriteXmlAttrDefLickedState(_value: any);
begin
    if ifnil({self.}XmlAttrDefLickedState) then
    begin
        {self.}XmlAttrDefLickedState := new OpenXmlAttribute({self.}Prefix, "defLickedState", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "defLickedState" : "defLickedState"] := {self.}XmlAttrDefLickedState;
    end
    {self.}XmlAttrDefLickedState.Value := _value;
end;

function LatenStyles.ReadXmlAttrDefUIPriority();
begin
    return ifnil({self.}XmlAttrDefUIPriority.Value) ? fallback_.XmlAttrDefUIPriority.Value : {self.}XmlAttrDefUIPriority.Value;
end;

function LatenStyles.WriteXmlAttrDefUIPriority(_value: any);
begin
    if ifnil({self.}XmlAttrDefUIPriority) then
    begin
        {self.}XmlAttrDefUIPriority := new OpenXmlAttribute({self.}Prefix, "defUIPriority", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "defUIPriority" : "defUIPriority"] := {self.}XmlAttrDefUIPriority;
    end
    {self.}XmlAttrDefUIPriority.Value := _value;
end;

function LatenStyles.ReadXmlAttrDefSemiHidden();
begin
    return ifnil({self.}XmlAttrDefSemiHidden.Value) ? fallback_.XmlAttrDefSemiHidden.Value : {self.}XmlAttrDefSemiHidden.Value;
end;

function LatenStyles.WriteXmlAttrDefSemiHidden(_value: any);
begin
    if ifnil({self.}XmlAttrDefSemiHidden) then
    begin
        {self.}XmlAttrDefSemiHidden := new OpenXmlAttribute({self.}Prefix, "defSemiHidden", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "defSemiHidden" : "defSemiHidden"] := {self.}XmlAttrDefSemiHidden;
    end
    {self.}XmlAttrDefSemiHidden.Value := _value;
end;

function LatenStyles.ReadXmlAttrDefUnhideWhenUsed();
begin
    return ifnil({self.}XmlAttrDefUnhideWhenUsed.Value) ? fallback_.XmlAttrDefUnhideWhenUsed.Value : {self.}XmlAttrDefUnhideWhenUsed.Value;
end;

function LatenStyles.WriteXmlAttrDefUnhideWhenUsed(_value: any);
begin
    if ifnil({self.}XmlAttrDefUnhideWhenUsed) then
    begin
        {self.}XmlAttrDefUnhideWhenUsed := new OpenXmlAttribute({self.}Prefix, "defUnhideWhenUsed", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "defUnhideWhenUsed" : "defUnhideWhenUsed"] := {self.}XmlAttrDefUnhideWhenUsed;
    end
    {self.}XmlAttrDefUnhideWhenUsed.Value := _value;
end;

function LatenStyles.ReadXmlAttrDefQFormat();
begin
    return ifnil({self.}XmlAttrDefQFormat.Value) ? fallback_.XmlAttrDefQFormat.Value : {self.}XmlAttrDefQFormat.Value;
end;

function LatenStyles.WriteXmlAttrDefQFormat(_value: any);
begin
    if ifnil({self.}XmlAttrDefQFormat) then
    begin
        {self.}XmlAttrDefQFormat := new OpenXmlAttribute({self.}Prefix, "defQFormat", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "defQFormat" : "defQFormat"] := {self.}XmlAttrDefQFormat;
    end
    {self.}XmlAttrDefQFormat.Value := _value;
end;

function LatenStyles.ReadXmlAttrCount();
begin
    return ifnil({self.}XmlAttrCount.Value) ? fallback_.XmlAttrCount.Value : {self.}XmlAttrCount.Value;
end;

function LatenStyles.WriteXmlAttrCount(_value: any);
begin
    if ifnil({self.}XmlAttrCount) then
    begin
        {self.}XmlAttrCount := new OpenXmlAttribute({self.}Prefix, "count", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "count" : "count"] := {self.}XmlAttrCount;
    end
    {self.}XmlAttrCount.Value := _value;
end;

function LatenStyles.ReadLsdExceptions(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "lsdException", ind);
end;

function LatenStyles.WriteLsdExceptions(_index: integer; _value: nil_OR_LsdException);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadLsdExceptions(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "lsdException", ind, _value) then
            raise format("Index out of range: LsdExceptions[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: LsdExceptions expects nil or LsdException";
    end
end;

function LatenStyles.AddLsdException(): LsdException;
begin
    obj := new LsdException(self, {self.}Prefix, "lsdException");
    container_.Insert(obj);
    return obj;
end;

function LatenStyles.AppendLsdException(): LsdException;
begin
    obj := new LsdException(self, {self.}Prefix, "lsdException");
    container_.Append(obj);
    return obj;
end;

function LsdException.Create();overload;
begin
    {self.}Create(nil, "w", "lsdException");
end;

function LsdException.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function LsdException.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function LsdException.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "name": makeweakref(thisFunction(WriteXmlAttrName)),
        pre + "uiPriority": makeweakref(thisFunction(WriteXmlAttrUIPriority)),
        pre + "semiHidden": makeweakref(thisFunction(WriteXmlAttrSemiHidden)),
        pre + "unhideWhenUsed": makeweakref(thisFunction(WriteXmlAttrUnhideWhenUsed)),
        pre + "qFormat": makeweakref(thisFunction(WriteXmlAttrQFormat)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function LsdException.Copy(_obj: LsdException);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Name) then
        {self.}Name := _obj.Name;
    if not ifnil(_obj.UIPriority) then
        {self.}UIPriority := _obj.UIPriority;
    if not ifnil(_obj.SemiHidden) then
        {self.}SemiHidden := _obj.SemiHidden;
    if not ifnil(_obj.UnhideWhenUsed) then
        {self.}UnhideWhenUsed := _obj.UnhideWhenUsed;
    if not ifnil(_obj.QFormat) then
        {self.}QFormat := _obj.QFormat;
    tslassigning := tslassigning_backup;
end;

function LsdException.ConvertToPoint();override;
begin

end;

function LsdException.ReadXmlAttrName();
begin
    return ifnil({self.}XmlAttrName.Value) ? fallback_.XmlAttrName.Value : {self.}XmlAttrName.Value;
end;

function LsdException.WriteXmlAttrName(_value: any);
begin
    if ifnil({self.}XmlAttrName) then
    begin
        {self.}XmlAttrName := new OpenXmlAttribute({self.}Prefix, "name", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "name" : "name"] := {self.}XmlAttrName;
    end
    {self.}XmlAttrName.Value := _value;
end;

function LsdException.ReadXmlAttrUIPriority();
begin
    return ifnil({self.}XmlAttrUIPriority.Value) ? fallback_.XmlAttrUIPriority.Value : {self.}XmlAttrUIPriority.Value;
end;

function LsdException.WriteXmlAttrUIPriority(_value: any);
begin
    if ifnil({self.}XmlAttrUIPriority) then
    begin
        {self.}XmlAttrUIPriority := new OpenXmlAttribute({self.}Prefix, "uiPriority", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "uiPriority" : "uiPriority"] := {self.}XmlAttrUIPriority;
    end
    {self.}XmlAttrUIPriority.Value := _value;
end;

function LsdException.ReadXmlAttrSemiHidden();
begin
    return ifnil({self.}XmlAttrSemiHidden.Value) ? fallback_.XmlAttrSemiHidden.Value : {self.}XmlAttrSemiHidden.Value;
end;

function LsdException.WriteXmlAttrSemiHidden(_value: any);
begin
    if ifnil({self.}XmlAttrSemiHidden) then
    begin
        {self.}XmlAttrSemiHidden := new OpenXmlAttribute({self.}Prefix, "semiHidden", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "semiHidden" : "semiHidden"] := {self.}XmlAttrSemiHidden;
    end
    {self.}XmlAttrSemiHidden.Value := _value;
end;

function LsdException.ReadXmlAttrUnhideWhenUsed();
begin
    return ifnil({self.}XmlAttrUnhideWhenUsed.Value) ? fallback_.XmlAttrUnhideWhenUsed.Value : {self.}XmlAttrUnhideWhenUsed.Value;
end;

function LsdException.WriteXmlAttrUnhideWhenUsed(_value: any);
begin
    if ifnil({self.}XmlAttrUnhideWhenUsed) then
    begin
        {self.}XmlAttrUnhideWhenUsed := new OpenXmlAttribute({self.}Prefix, "unhideWhenUsed", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "unhideWhenUsed" : "unhideWhenUsed"] := {self.}XmlAttrUnhideWhenUsed;
    end
    {self.}XmlAttrUnhideWhenUsed.Value := _value;
end;

function LsdException.ReadXmlAttrQFormat();
begin
    return ifnil({self.}XmlAttrQFormat.Value) ? fallback_.XmlAttrQFormat.Value : {self.}XmlAttrQFormat.Value;
end;

function LsdException.WriteXmlAttrQFormat(_value: any);
begin
    if ifnil({self.}XmlAttrQFormat) then
    begin
        {self.}XmlAttrQFormat := new OpenXmlAttribute({self.}Prefix, "qFormat", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "qFormat" : "qFormat"] := {self.}XmlAttrQFormat;
    end
    {self.}XmlAttrQFormat.Value := _value;
end;

function Style.Create();overload;
begin
    {self.}Create(nil, "w", "style");
end;

function Style.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Style.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Style.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "type": makeweakref(thisFunction(WriteXmlAttrType)),
        pre + "default": makeweakref(thisFunction(WriteXmlAttrDefault)),
        pre + "styleId": makeweakref(thisFunction(WriteXmlAttrStyleId)),
    );
    sorted_child_ := array(
        pre + "name": array(0, makeweakref(thisFunction(ReadXmlChildName))),
        pre + "basedOn": array(1, makeweakref(thisFunction(ReadXmlChildBasedOn))),
        pre + "next": array(2, makeweakref(thisFunction(ReadXmlChildNext))),
        pre + "autoRedefine": array(3, makeweakref(thisFunction(ReadXmlChildAutoRedefine))),
        pre + "link": array(4, makeweakref(thisFunction(ReadXmlChildLink))),
        pre + "uiPriority": array(5, makeweakref(thisFunction(ReadXmlChildUIPriority))),
        pre + "semiHidden": array(6, makeweakref(thisFunction(ReadXmlChildSemiHidden))),
        pre + "unhideWhenUsed": array(7, makeweakref(thisFunction(ReadXmlChildUnhideWhenUsed))),
        pre + "qFormat": array(8, makeweakref(thisFunction(ReadXmlChildQFormat))),
        pre + "rsid": array(9, makeweakref(thisFunction(ReadXmlChildRsid))),
        pre + "pPr": array(10, makeweakref(thisFunction(ReadXmlChildPPr))),
        pre + "rPr": array(11, makeweakref(thisFunction(ReadXmlChildRPr))),
        pre + "tblPr": array(12, makeweakref(thisFunction(ReadXmlChildTblPr))),
        pre + "trPr": array(13, makeweakref(thisFunction(ReadXmlChildTrPr))),
        pre + "tcPr": array(14, makeweakref(thisFunction(ReadXmlChildTcPr))),
        pre + "tblStylePr": array(15, makeweakref(thisFunction(AppendTblStylePr))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Style.Copy(_obj: Style);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Type) then
        {self.}Type := _obj.Type;
    if not ifnil(_obj.Default) then
        {self.}Default := _obj.Default;
    if not ifnil(_obj.StyleId) then
        {self.}StyleId := _obj.StyleId;
    if not ifnil(_obj.XmlChildName) then
        {self.}Name.Copy(_obj.XmlChildName);
    if not ifnil(_obj.XmlChildBasedOn) then
        {self.}BasedOn.Copy(_obj.XmlChildBasedOn);
    if not ifnil(_obj.XmlChildNext) then
        {self.}Next.Copy(_obj.XmlChildNext);
    if not ifnil(_obj.XmlChildAutoRedefine) then
        {self.}AutoRedefine.Copy(_obj.XmlChildAutoRedefine);
    if not ifnil(_obj.XmlChildLink) then
        {self.}Link.Copy(_obj.XmlChildLink);
    if not ifnil(_obj.XmlChildUIPriority) then
        {self.}UIPriority.Copy(_obj.XmlChildUIPriority);
    if not ifnil(_obj.XmlChildSemiHidden) then
        ifnil({self.}XmlChildSemiHidden) ? {self.}SemiHidden.Copy(_obj.XmlChildSemiHidden) : {self.}XmlChildSemiHidden.Copy(_obj.XmlChildSemiHidden);
    if not ifnil(_obj.XmlChildUnhideWhenUsed) then
        ifnil({self.}XmlChildUnhideWhenUsed) ? {self.}UnhideWhenUsed.Copy(_obj.XmlChildUnhideWhenUsed) : {self.}XmlChildUnhideWhenUsed.Copy(_obj.XmlChildUnhideWhenUsed);
    if not ifnil(_obj.XmlChildQFormat) then
        ifnil({self.}XmlChildQFormat) ? {self.}QFormat.Copy(_obj.XmlChildQFormat) : {self.}XmlChildQFormat.Copy(_obj.XmlChildQFormat);
    if not ifnil(_obj.XmlChildRsid) then
        ifnil({self.}XmlChildRsid) ? {self.}Rsid.Copy(_obj.XmlChildRsid) : {self.}XmlChildRsid.Copy(_obj.XmlChildRsid);
    if not ifnil(_obj.XmlChildPPr) then
        {self.}PPr.Copy(_obj.XmlChildPPr);
    if not ifnil(_obj.XmlChildRPr) then
        {self.}RPr.Copy(_obj.XmlChildRPr);
    if not ifnil(_obj.XmlChildTblPr) then
        {self.}TblPr.Copy(_obj.XmlChildTblPr);
    if not ifnil(_obj.XmlChildTrPr) then
        {self.}TrPr.Copy(_obj.XmlChildTrPr);
    if not ifnil(_obj.XmlChildTcPr) then
        {self.}TcPr.Copy(_obj.XmlChildTcPr);
    tslassigning := tslassigning_backup;
end;

function Style.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildName) then
        {self.}XmlChildName.ConvertToPoint();
    if not ifnil({self.}XmlChildBasedOn) then
        {self.}XmlChildBasedOn.ConvertToPoint();
    if not ifnil({self.}XmlChildNext) then
        {self.}XmlChildNext.ConvertToPoint();
    if not ifnil({self.}XmlChildAutoRedefine) then
        {self.}XmlChildAutoRedefine.ConvertToPoint();
    if not ifnil({self.}XmlChildLink) then
        {self.}XmlChildLink.ConvertToPoint();
    if not ifnil({self.}XmlChildUIPriority) then
        {self.}XmlChildUIPriority.ConvertToPoint();
    if not ifnil({self.}XmlChildPPr) then
        {self.}XmlChildPPr.ConvertToPoint();
    if not ifnil({self.}XmlChildRPr) then
        {self.}XmlChildRPr.ConvertToPoint();
    if not ifnil({self.}XmlChildTblPr) then
        {self.}XmlChildTblPr.ConvertToPoint();
    if not ifnil({self.}XmlChildTrPr) then
        {self.}XmlChildTrPr.ConvertToPoint();
    if not ifnil({self.}XmlChildTcPr) then
        {self.}XmlChildTcPr.ConvertToPoint();
    elems := {self.}TblStylePrs();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Style.ReadXmlAttrType();
begin
    return ifnil({self.}XmlAttrType.Value) ? fallback_.XmlAttrType.Value : {self.}XmlAttrType.Value;
end;

function Style.WriteXmlAttrType(_value: any);
begin
    if ifnil({self.}XmlAttrType) then
    begin
        {self.}XmlAttrType := new OpenXmlAttribute({self.}Prefix, "type", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "type" : "type"] := {self.}XmlAttrType;
    end
    {self.}XmlAttrType.Value := _value;
end;

function Style.ReadXmlAttrDefault();
begin
    return ifnil({self.}XmlAttrDefault.Value) ? fallback_.XmlAttrDefault.Value : {self.}XmlAttrDefault.Value;
end;

function Style.WriteXmlAttrDefault(_value: any);
begin
    if ifnil({self.}XmlAttrDefault) then
    begin
        {self.}XmlAttrDefault := new OpenXmlAttribute({self.}Prefix, "default", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "default" : "default"] := {self.}XmlAttrDefault;
    end
    {self.}XmlAttrDefault.Value := _value;
end;

function Style.ReadXmlAttrStyleId();
begin
    return ifnil({self.}XmlAttrStyleId.Value) ? fallback_.XmlAttrStyleId.Value : {self.}XmlAttrStyleId.Value;
end;

function Style.WriteXmlAttrStyleId(_value: any);
begin
    if ifnil({self.}XmlAttrStyleId) then
    begin
        {self.}XmlAttrStyleId := new OpenXmlAttribute({self.}Prefix, "styleId", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "styleId" : "styleId"] := {self.}XmlAttrStyleId;
    end
    {self.}XmlAttrStyleId.Value := _value;
end;

function Style.ReadXmlChildSemiHidden();
begin
    if tslassigning and (ifnil({self.}XmlChildSemiHidden) or {self.}XmlChildSemiHidden.Removed) then
    begin
        {self.}XmlChildSemiHidden := new OpenXmlSimpleType(self, {self.}Prefix, "semiHidden");
        container_.Set({self.}XmlChildSemiHidden);
    end
    return {self.}XmlChildSemiHidden and not {self.}XmlChildSemiHidden.Removed ? {self.}XmlChildSemiHidden : fallback_.XmlChildSemiHidden;
end;

function Style.WriteXmlChildSemiHidden(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildSemiHidden) then
            {self.}RemoveChild({self.}XmlChildSemiHidden);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildSemiHidden := _value;
        container_.Set({self.}XmlChildSemiHidden);
    end
    else begin
        raise "Invalid assignment: SemiHidden expects nil or OpenXmlSimpleType";
    end
end;

function Style.ReadXmlChildUnhideWhenUsed();
begin
    if tslassigning and (ifnil({self.}XmlChildUnhideWhenUsed) or {self.}XmlChildUnhideWhenUsed.Removed) then
    begin
        {self.}XmlChildUnhideWhenUsed := new OpenXmlSimpleType(self, {self.}Prefix, "unhideWhenUsed");
        container_.Set({self.}XmlChildUnhideWhenUsed);
    end
    return {self.}XmlChildUnhideWhenUsed and not {self.}XmlChildUnhideWhenUsed.Removed ? {self.}XmlChildUnhideWhenUsed : fallback_.XmlChildUnhideWhenUsed;
end;

function Style.WriteXmlChildUnhideWhenUsed(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildUnhideWhenUsed) then
            {self.}RemoveChild({self.}XmlChildUnhideWhenUsed);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildUnhideWhenUsed := _value;
        container_.Set({self.}XmlChildUnhideWhenUsed);
    end
    else begin
        raise "Invalid assignment: UnhideWhenUsed expects nil or OpenXmlSimpleType";
    end
end;

function Style.ReadXmlChildQFormat();
begin
    if tslassigning and (ifnil({self.}XmlChildQFormat) or {self.}XmlChildQFormat.Removed) then
    begin
        {self.}XmlChildQFormat := new OpenXmlSimpleType(self, {self.}Prefix, "qFormat");
        container_.Set({self.}XmlChildQFormat);
    end
    return {self.}XmlChildQFormat and not {self.}XmlChildQFormat.Removed ? {self.}XmlChildQFormat : fallback_.XmlChildQFormat;
end;

function Style.WriteXmlChildQFormat(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildQFormat) then
            {self.}RemoveChild({self.}XmlChildQFormat);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildQFormat := _value;
        container_.Set({self.}XmlChildQFormat);
    end
    else begin
        raise "Invalid assignment: QFormat expects nil or OpenXmlSimpleType";
    end
end;

function Style.ReadXmlChildRsid();
begin
    if tslassigning and (ifnil({self.}XmlChildRsid) or {self.}XmlChildRsid.Removed) then
    begin
        {self.}XmlChildRsid := new OpenXmlSimpleType(self, {self.}Prefix, "rsid");
        container_.Set({self.}XmlChildRsid);
    end
    return {self.}XmlChildRsid and not {self.}XmlChildRsid.Removed ? {self.}XmlChildRsid : fallback_.XmlChildRsid;
end;

function Style.WriteXmlChildRsid(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildRsid) then
            {self.}RemoveChild({self.}XmlChildRsid);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildRsid := _value;
        container_.Set({self.}XmlChildRsid);
    end
    else begin
        raise "Invalid assignment: Rsid expects nil or OpenXmlSimpleType";
    end
end;

function Style.ReadXmlChildName(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildName) or {self.}XmlChildName.Removed) then
    begin
        {self.}XmlChildName := new PureWVal(self, {self.}Prefix, "name");
        container_.Set({self.}XmlChildName);
    end
    return {self.}XmlChildName and not {self.}XmlChildName.Removed ? {self.}XmlChildName : fallback_.XmlChildName;
end;

function Style.WriteXmlChildName(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildName) then
            {self.}RemoveChild({self.}XmlChildName);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildName := v;
        container_.Set({self.}XmlChildName);
    end
    else begin
        raise "Invalid assignment: Name expects PureWVal or nil";
    end
end;

function Style.ReadXmlChildBasedOn(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildBasedOn) or {self.}XmlChildBasedOn.Removed) then
    begin
        {self.}XmlChildBasedOn := new PureWVal(self, {self.}Prefix, "basedOn");
        container_.Set({self.}XmlChildBasedOn);
    end
    return {self.}XmlChildBasedOn and not {self.}XmlChildBasedOn.Removed ? {self.}XmlChildBasedOn : fallback_.XmlChildBasedOn;
end;

function Style.WriteXmlChildBasedOn(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildBasedOn) then
            {self.}RemoveChild({self.}XmlChildBasedOn);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildBasedOn := v;
        container_.Set({self.}XmlChildBasedOn);
    end
    else begin
        raise "Invalid assignment: BasedOn expects PureWVal or nil";
    end
end;

function Style.ReadXmlChildNext(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildNext) or {self.}XmlChildNext.Removed) then
    begin
        {self.}XmlChildNext := new PureWVal(self, {self.}Prefix, "next");
        container_.Set({self.}XmlChildNext);
    end
    return {self.}XmlChildNext and not {self.}XmlChildNext.Removed ? {self.}XmlChildNext : fallback_.XmlChildNext;
end;

function Style.WriteXmlChildNext(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildNext) then
            {self.}RemoveChild({self.}XmlChildNext);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildNext := v;
        container_.Set({self.}XmlChildNext);
    end
    else begin
        raise "Invalid assignment: Next expects PureWVal or nil";
    end
end;

function Style.ReadXmlChildAutoRedefine(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildAutoRedefine) or {self.}XmlChildAutoRedefine.Removed) then
    begin
        {self.}XmlChildAutoRedefine := new PureWVal(self, {self.}Prefix, "autoRedefine");
        container_.Set({self.}XmlChildAutoRedefine);
    end
    return {self.}XmlChildAutoRedefine and not {self.}XmlChildAutoRedefine.Removed ? {self.}XmlChildAutoRedefine : fallback_.XmlChildAutoRedefine;
end;

function Style.WriteXmlChildAutoRedefine(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildAutoRedefine) then
            {self.}RemoveChild({self.}XmlChildAutoRedefine);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildAutoRedefine := v;
        container_.Set({self.}XmlChildAutoRedefine);
    end
    else begin
        raise "Invalid assignment: AutoRedefine expects PureWVal or nil";
    end
end;

function Style.ReadXmlChildLink(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildLink) or {self.}XmlChildLink.Removed) then
    begin
        {self.}XmlChildLink := new PureWVal(self, {self.}Prefix, "link");
        container_.Set({self.}XmlChildLink);
    end
    return {self.}XmlChildLink and not {self.}XmlChildLink.Removed ? {self.}XmlChildLink : fallback_.XmlChildLink;
end;

function Style.WriteXmlChildLink(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildLink) then
            {self.}RemoveChild({self.}XmlChildLink);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildLink := v;
        container_.Set({self.}XmlChildLink);
    end
    else begin
        raise "Invalid assignment: Link expects PureWVal or nil";
    end
end;

function Style.ReadXmlChildUIPriority(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildUIPriority) or {self.}XmlChildUIPriority.Removed) then
    begin
        {self.}XmlChildUIPriority := new PureWVal(self, {self.}Prefix, "uiPriority");
        container_.Set({self.}XmlChildUIPriority);
    end
    return {self.}XmlChildUIPriority and not {self.}XmlChildUIPriority.Removed ? {self.}XmlChildUIPriority : fallback_.XmlChildUIPriority;
end;

function Style.WriteXmlChildUIPriority(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildUIPriority) then
            {self.}RemoveChild({self.}XmlChildUIPriority);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildUIPriority := v;
        container_.Set({self.}XmlChildUIPriority);
    end
    else begin
        raise "Invalid assignment: UIPriority expects PureWVal or nil";
    end
end;

function Style.ReadXmlChildPPr(): PPr;
begin
    if tslassigning and (ifnil({self.}XmlChildPPr) or {self.}XmlChildPPr.Removed) then
    begin
        {self.}XmlChildPPr := new PPr(self, {self.}Prefix, "pPr");
        container_.Set({self.}XmlChildPPr);
    end
    return {self.}XmlChildPPr and not {self.}XmlChildPPr.Removed ? {self.}XmlChildPPr : fallback_.XmlChildPPr;
end;

function Style.WriteXmlChildPPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPPr) then
            {self.}RemoveChild({self.}XmlChildPPr);
    end
    else if v is class(PPr) then
    begin
        {self.}XmlChildPPr := v;
        container_.Set({self.}XmlChildPPr);
    end
    else begin
        raise "Invalid assignment: PPr expects PPr or nil";
    end
end;

function Style.ReadXmlChildRPr(): RPr;
begin
    if tslassigning and (ifnil({self.}XmlChildRPr) or {self.}XmlChildRPr.Removed) then
    begin
        {self.}XmlChildRPr := new RPr(self, {self.}Prefix, "rPr");
        container_.Set({self.}XmlChildRPr);
    end
    return {self.}XmlChildRPr and not {self.}XmlChildRPr.Removed ? {self.}XmlChildRPr : fallback_.XmlChildRPr;
end;

function Style.WriteXmlChildRPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRPr) then
            {self.}RemoveChild({self.}XmlChildRPr);
    end
    else if v is class(RPr) then
    begin
        {self.}XmlChildRPr := v;
        container_.Set({self.}XmlChildRPr);
    end
    else begin
        raise "Invalid assignment: RPr expects RPr or nil";
    end
end;

function Style.ReadXmlChildTblPr(): TblPr;
begin
    if tslassigning and (ifnil({self.}XmlChildTblPr) or {self.}XmlChildTblPr.Removed) then
    begin
        {self.}XmlChildTblPr := new TblPr(self, {self.}Prefix, "tblPr");
        container_.Set({self.}XmlChildTblPr);
    end
    return {self.}XmlChildTblPr and not {self.}XmlChildTblPr.Removed ? {self.}XmlChildTblPr : fallback_.XmlChildTblPr;
end;

function Style.WriteXmlChildTblPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTblPr) then
            {self.}RemoveChild({self.}XmlChildTblPr);
    end
    else if v is class(TblPr) then
    begin
        {self.}XmlChildTblPr := v;
        container_.Set({self.}XmlChildTblPr);
    end
    else begin
        raise "Invalid assignment: TblPr expects TblPr or nil";
    end
end;

function Style.ReadXmlChildTrPr(): TrPr;
begin
    if tslassigning and (ifnil({self.}XmlChildTrPr) or {self.}XmlChildTrPr.Removed) then
    begin
        {self.}XmlChildTrPr := new TrPr(self, {self.}Prefix, "trPr");
        container_.Set({self.}XmlChildTrPr);
    end
    return {self.}XmlChildTrPr and not {self.}XmlChildTrPr.Removed ? {self.}XmlChildTrPr : fallback_.XmlChildTrPr;
end;

function Style.WriteXmlChildTrPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTrPr) then
            {self.}RemoveChild({self.}XmlChildTrPr);
    end
    else if v is class(TrPr) then
    begin
        {self.}XmlChildTrPr := v;
        container_.Set({self.}XmlChildTrPr);
    end
    else begin
        raise "Invalid assignment: TrPr expects TrPr or nil";
    end
end;

function Style.ReadXmlChildTcPr(): TcPr;
begin
    if tslassigning and (ifnil({self.}XmlChildTcPr) or {self.}XmlChildTcPr.Removed) then
    begin
        {self.}XmlChildTcPr := new TcPr(self, {self.}Prefix, "tcPr");
        container_.Set({self.}XmlChildTcPr);
    end
    return {self.}XmlChildTcPr and not {self.}XmlChildTcPr.Removed ? {self.}XmlChildTcPr : fallback_.XmlChildTcPr;
end;

function Style.WriteXmlChildTcPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTcPr) then
            {self.}RemoveChild({self.}XmlChildTcPr);
    end
    else if v is class(TcPr) then
    begin
        {self.}XmlChildTcPr := v;
        container_.Set({self.}XmlChildTcPr);
    end
    else begin
        raise "Invalid assignment: TcPr expects TcPr or nil";
    end
end;

function Style.ReadTblStylePrs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "tblStylePr", ind);
end;

function Style.WriteTblStylePrs(_index: integer; _value: nil_OR_TblStylePr);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadTblStylePrs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "tblStylePr", ind, _value) then
            raise format("Index out of range: TblStylePrs[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: TblStylePrs expects nil or TblStylePr";
    end
end;

function Style.AddTblStylePr(): TblStylePr;
begin
    obj := new TblStylePr(self, {self.}Prefix, "tblStylePr");
    container_.Insert(obj);
    return obj;
end;

function Style.AppendTblStylePr(): TblStylePr;
begin
    obj := new TblStylePr(self, {self.}Prefix, "tblStylePr");
    container_.Append(obj);
    return obj;
end;

function TblStylePr.Create();overload;
begin
    {self.}Create(nil, "w", "tblStylePr");
end;

function TblStylePr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TblStylePr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TblStylePr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "type": makeweakref(thisFunction(WriteXmlAttrType)),
    );
    sorted_child_ := array(
        pre + "pPr": array(0, makeweakref(thisFunction(ReadXmlChildPPr))),
        pre + "rPr": array(1, makeweakref(thisFunction(ReadXmlChildRPr))),
        pre + "tblPr": array(2, makeweakref(thisFunction(ReadXmlChildTblPr))),
        pre + "trPr": array(3, makeweakref(thisFunction(ReadXmlChildTrPr))),
        pre + "tcPr": array(4, makeweakref(thisFunction(ReadXmlChildTcPr))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TblStylePr.Copy(_obj: TblStylePr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Type) then
        {self.}Type := _obj.Type;
    if not ifnil(_obj.XmlChildPPr) then
        {self.}PPr.Copy(_obj.XmlChildPPr);
    if not ifnil(_obj.XmlChildRPr) then
        {self.}RPr.Copy(_obj.XmlChildRPr);
    if not ifnil(_obj.XmlChildTblPr) then
        {self.}TblPr.Copy(_obj.XmlChildTblPr);
    if not ifnil(_obj.XmlChildTrPr) then
        {self.}TrPr.Copy(_obj.XmlChildTrPr);
    if not ifnil(_obj.XmlChildTcPr) then
        {self.}TcPr.Copy(_obj.XmlChildTcPr);
    tslassigning := tslassigning_backup;
end;

function TblStylePr.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildPPr) then
        {self.}XmlChildPPr.ConvertToPoint();
    if not ifnil({self.}XmlChildRPr) then
        {self.}XmlChildRPr.ConvertToPoint();
    if not ifnil({self.}XmlChildTblPr) then
        {self.}XmlChildTblPr.ConvertToPoint();
    if not ifnil({self.}XmlChildTrPr) then
        {self.}XmlChildTrPr.ConvertToPoint();
    if not ifnil({self.}XmlChildTcPr) then
        {self.}XmlChildTcPr.ConvertToPoint();
end;

function TblStylePr.ReadXmlAttrType();
begin
    return ifnil({self.}XmlAttrType.Value) ? fallback_.XmlAttrType.Value : {self.}XmlAttrType.Value;
end;

function TblStylePr.WriteXmlAttrType(_value: any);
begin
    if ifnil({self.}XmlAttrType) then
    begin
        {self.}XmlAttrType := new OpenXmlAttribute({self.}Prefix, "type", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "type" : "type"] := {self.}XmlAttrType;
    end
    {self.}XmlAttrType.Value := _value;
end;

function TblStylePr.ReadXmlChildPPr(): PPr;
begin
    if tslassigning and (ifnil({self.}XmlChildPPr) or {self.}XmlChildPPr.Removed) then
    begin
        {self.}XmlChildPPr := new PPr(self, {self.}Prefix, "pPr");
        container_.Set({self.}XmlChildPPr);
    end
    return {self.}XmlChildPPr and not {self.}XmlChildPPr.Removed ? {self.}XmlChildPPr : fallback_.XmlChildPPr;
end;

function TblStylePr.WriteXmlChildPPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPPr) then
            {self.}RemoveChild({self.}XmlChildPPr);
    end
    else if v is class(PPr) then
    begin
        {self.}XmlChildPPr := v;
        container_.Set({self.}XmlChildPPr);
    end
    else begin
        raise "Invalid assignment: PPr expects PPr or nil";
    end
end;

function TblStylePr.ReadXmlChildRPr(): RPr;
begin
    if tslassigning and (ifnil({self.}XmlChildRPr) or {self.}XmlChildRPr.Removed) then
    begin
        {self.}XmlChildRPr := new RPr(self, {self.}Prefix, "rPr");
        container_.Set({self.}XmlChildRPr);
    end
    return {self.}XmlChildRPr and not {self.}XmlChildRPr.Removed ? {self.}XmlChildRPr : fallback_.XmlChildRPr;
end;

function TblStylePr.WriteXmlChildRPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRPr) then
            {self.}RemoveChild({self.}XmlChildRPr);
    end
    else if v is class(RPr) then
    begin
        {self.}XmlChildRPr := v;
        container_.Set({self.}XmlChildRPr);
    end
    else begin
        raise "Invalid assignment: RPr expects RPr or nil";
    end
end;

function TblStylePr.ReadXmlChildTblPr(): TblPr;
begin
    if tslassigning and (ifnil({self.}XmlChildTblPr) or {self.}XmlChildTblPr.Removed) then
    begin
        {self.}XmlChildTblPr := new TblPr(self, {self.}Prefix, "tblPr");
        container_.Set({self.}XmlChildTblPr);
    end
    return {self.}XmlChildTblPr and not {self.}XmlChildTblPr.Removed ? {self.}XmlChildTblPr : fallback_.XmlChildTblPr;
end;

function TblStylePr.WriteXmlChildTblPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTblPr) then
            {self.}RemoveChild({self.}XmlChildTblPr);
    end
    else if v is class(TblPr) then
    begin
        {self.}XmlChildTblPr := v;
        container_.Set({self.}XmlChildTblPr);
    end
    else begin
        raise "Invalid assignment: TblPr expects TblPr or nil";
    end
end;

function TblStylePr.ReadXmlChildTrPr(): TrPr;
begin
    if tslassigning and (ifnil({self.}XmlChildTrPr) or {self.}XmlChildTrPr.Removed) then
    begin
        {self.}XmlChildTrPr := new TrPr(self, {self.}Prefix, "trPr");
        container_.Set({self.}XmlChildTrPr);
    end
    return {self.}XmlChildTrPr and not {self.}XmlChildTrPr.Removed ? {self.}XmlChildTrPr : fallback_.XmlChildTrPr;
end;

function TblStylePr.WriteXmlChildTrPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTrPr) then
            {self.}RemoveChild({self.}XmlChildTrPr);
    end
    else if v is class(TrPr) then
    begin
        {self.}XmlChildTrPr := v;
        container_.Set({self.}XmlChildTrPr);
    end
    else begin
        raise "Invalid assignment: TrPr expects TrPr or nil";
    end
end;

function TblStylePr.ReadXmlChildTcPr(): TcPr;
begin
    if tslassigning and (ifnil({self.}XmlChildTcPr) or {self.}XmlChildTcPr.Removed) then
    begin
        {self.}XmlChildTcPr := new TcPr(self, {self.}Prefix, "tcPr");
        container_.Set({self.}XmlChildTcPr);
    end
    return {self.}XmlChildTcPr and not {self.}XmlChildTcPr.Removed ? {self.}XmlChildTcPr : fallback_.XmlChildTcPr;
end;

function TblStylePr.WriteXmlChildTcPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTcPr) then
            {self.}RemoveChild({self.}XmlChildTcPr);
    end
    else if v is class(TcPr) then
    begin
        {self.}XmlChildTcPr := v;
        container_.Set({self.}XmlChildTcPr);
    end
    else begin
        raise "Invalid assignment: TcPr expects TcPr or nil";
    end
end;

function TblInd.Create();overload;
begin
    {self.}Create(nil, "w", "tblInd");
end;

function TblInd.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TblInd.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TblInd.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "w": makeweakref(thisFunction(WriteXmlAttrW)),
        pre + "type": makeweakref(thisFunction(WriteXmlAttrType)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TblInd.Copy(_obj: TblInd);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.W) then
        {self.}W := _obj.W;
    if not ifnil(_obj.Type) then
        {self.}Type := _obj.Type;
    tslassigning := tslassigning_backup;
end;

function TblInd.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlAttrW) then
        {self.}W := TSSafeUnitConverter.TwipsToPoints({self.}XmlAttrW.Value);
end;

function TblInd.ReadXmlAttrW();
begin
    return ifnil({self.}XmlAttrW.Value) ? fallback_.XmlAttrW.Value : {self.}XmlAttrW.Value;
end;

function TblInd.WriteXmlAttrW(_value: any);
begin
    if ifnil({self.}XmlAttrW) then
    begin
        {self.}XmlAttrW := new OpenXmlAttribute({self.}Prefix, "w", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "w" : "w"] := {self.}XmlAttrW;
    end
    {self.}XmlAttrW.Value := _value;
end;

function TblInd.ReadXmlAttrType();
begin
    return ifnil({self.}XmlAttrType.Value) ? fallback_.XmlAttrType.Value : {self.}XmlAttrType.Value;
end;

function TblInd.WriteXmlAttrType(_value: any);
begin
    if ifnil({self.}XmlAttrType) then
    begin
        {self.}XmlAttrType := new OpenXmlAttribute({self.}Prefix, "type", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "type" : "type"] := {self.}XmlAttrType;
    end
    {self.}XmlAttrType.Value := _value;
end;

function TblCellMar.Create();overload;
begin
    {self.}Create(nil, "w", "tblCellMar");
end;

function TblCellMar.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function TblCellMar.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function TblCellMar.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "top": array(0, makeweakref(thisFunction(ReadXmlChildTop))),
        pre + "left": array(1, makeweakref(thisFunction(ReadXmlChildLeft))),
        pre + "bottom": array(2, makeweakref(thisFunction(ReadXmlChildBottom))),
        pre + "right": array(3, makeweakref(thisFunction(ReadXmlChildRight))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TblCellMar.Copy(_obj: TblCellMar);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildTop) then
        {self.}Top.Copy(_obj.XmlChildTop);
    if not ifnil(_obj.XmlChildLeft) then
        {self.}Left.Copy(_obj.XmlChildLeft);
    if not ifnil(_obj.XmlChildBottom) then
        {self.}Bottom.Copy(_obj.XmlChildBottom);
    if not ifnil(_obj.XmlChildRight) then
        {self.}Right.Copy(_obj.XmlChildRight);
    tslassigning := tslassigning_backup;
end;

function TblCellMar.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildTop) then
        {self.}XmlChildTop.ConvertToPoint();
    if not ifnil({self.}XmlChildLeft) then
        {self.}XmlChildLeft.ConvertToPoint();
    if not ifnil({self.}XmlChildBottom) then
        {self.}XmlChildBottom.ConvertToPoint();
    if not ifnil({self.}XmlChildRight) then
        {self.}XmlChildRight.ConvertToPoint();
end;

function TblCellMar.ReadXmlChildTop(): TblInd;
begin
    if tslassigning and (ifnil({self.}XmlChildTop) or {self.}XmlChildTop.Removed) then
    begin
        {self.}XmlChildTop := new TblInd(self, {self.}Prefix, "top");
        container_.Set({self.}XmlChildTop);
    end
    return {self.}XmlChildTop and not {self.}XmlChildTop.Removed ? {self.}XmlChildTop : fallback_.XmlChildTop;
end;

function TblCellMar.WriteXmlChildTop(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTop) then
            {self.}RemoveChild({self.}XmlChildTop);
    end
    else if v is class(TblInd) then
    begin
        {self.}XmlChildTop := v;
        container_.Set({self.}XmlChildTop);
    end
    else begin
        raise "Invalid assignment: Top expects TblInd or nil";
    end
end;

function TblCellMar.ReadXmlChildLeft(): TblInd;
begin
    if tslassigning and (ifnil({self.}XmlChildLeft) or {self.}XmlChildLeft.Removed) then
    begin
        {self.}XmlChildLeft := new TblInd(self, {self.}Prefix, "left");
        container_.Set({self.}XmlChildLeft);
    end
    return {self.}XmlChildLeft and not {self.}XmlChildLeft.Removed ? {self.}XmlChildLeft : fallback_.XmlChildLeft;
end;

function TblCellMar.WriteXmlChildLeft(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildLeft) then
            {self.}RemoveChild({self.}XmlChildLeft);
    end
    else if v is class(TblInd) then
    begin
        {self.}XmlChildLeft := v;
        container_.Set({self.}XmlChildLeft);
    end
    else begin
        raise "Invalid assignment: Left expects TblInd or nil";
    end
end;

function TblCellMar.ReadXmlChildBottom(): TblInd;
begin
    if tslassigning and (ifnil({self.}XmlChildBottom) or {self.}XmlChildBottom.Removed) then
    begin
        {self.}XmlChildBottom := new TblInd(self, {self.}Prefix, "bottom");
        container_.Set({self.}XmlChildBottom);
    end
    return {self.}XmlChildBottom and not {self.}XmlChildBottom.Removed ? {self.}XmlChildBottom : fallback_.XmlChildBottom;
end;

function TblCellMar.WriteXmlChildBottom(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildBottom) then
            {self.}RemoveChild({self.}XmlChildBottom);
    end
    else if v is class(TblInd) then
    begin
        {self.}XmlChildBottom := v;
        container_.Set({self.}XmlChildBottom);
    end
    else begin
        raise "Invalid assignment: Bottom expects TblInd or nil";
    end
end;

function TblCellMar.ReadXmlChildRight(): TblInd;
begin
    if tslassigning and (ifnil({self.}XmlChildRight) or {self.}XmlChildRight.Removed) then
    begin
        {self.}XmlChildRight := new TblInd(self, {self.}Prefix, "right");
        container_.Set({self.}XmlChildRight);
    end
    return {self.}XmlChildRight and not {self.}XmlChildRight.Removed ? {self.}XmlChildRight : fallback_.XmlChildRight;
end;

function TblCellMar.WriteXmlChildRight(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRight) then
            {self.}RemoveChild({self.}XmlChildRight);
    end
    else if v is class(TblInd) then
    begin
        {self.}XmlChildRight := v;
        container_.Set({self.}XmlChildRight);
    end
    else begin
        raise "Invalid assignment: Right expects TblInd or nil";
    end
end;

function WebSettings.Create();overload;
begin
    {self.}Create(nil, "w", "webSettings");
end;

function WebSettings.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function WebSettings.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function WebSettings.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "mc:Ignorable": makeweakref(thisFunction(WriteXmlAttrIgnorable)),
    );
    sorted_child_ := array(
        pre + "optimizeForBrowser": array(0, makeweakref(thisFunction(ReadXmlChildOptimizeForBrowser))),
        pre + "allowPNG": array(1, makeweakref(thisFunction(ReadXmlChildAllowPNG))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function WebSettings.Copy(_obj: WebSettings);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Ignorable) then
        {self.}Ignorable := _obj.Ignorable;
    if not ifnil(_obj.XmlChildOptimizeForBrowser) then
        ifnil({self.}XmlChildOptimizeForBrowser) ? {self.}OptimizeForBrowser.Copy(_obj.XmlChildOptimizeForBrowser) : {self.}XmlChildOptimizeForBrowser.Copy(_obj.XmlChildOptimizeForBrowser);
    if not ifnil(_obj.XmlChildAllowPNG) then
        ifnil({self.}XmlChildAllowPNG) ? {self.}AllowPNG.Copy(_obj.XmlChildAllowPNG) : {self.}XmlChildAllowPNG.Copy(_obj.XmlChildAllowPNG);
    tslassigning := tslassigning_backup;
end;

function WebSettings.ConvertToPoint();override;
begin

end;

function WebSettings.ReadXmlAttrIgnorable();
begin
    return ifnil({self.}XmlAttrIgnorable.Value) ? fallback_.XmlAttrIgnorable.Value : {self.}XmlAttrIgnorable.Value;
end;

function WebSettings.WriteXmlAttrIgnorable(_value: any);
begin
    if ifnil({self.}XmlAttrIgnorable) then
    begin
        {self.}XmlAttrIgnorable := new OpenXmlAttribute("mc", "Ignorable", nil);
        attributes_["mc:Ignorable"] := {self.}XmlAttrIgnorable;
    end
    {self.}XmlAttrIgnorable.Value := _value;
end;

function WebSettings.ReadXmlChildOptimizeForBrowser();
begin
    if tslassigning and (ifnil({self.}XmlChildOptimizeForBrowser) or {self.}XmlChildOptimizeForBrowser.Removed) then
    begin
        {self.}XmlChildOptimizeForBrowser := new OpenXmlSimpleType(self, {self.}Prefix, "optimizeForBrowser");
        container_.Set({self.}XmlChildOptimizeForBrowser);
    end
    return {self.}XmlChildOptimizeForBrowser and not {self.}XmlChildOptimizeForBrowser.Removed ? {self.}XmlChildOptimizeForBrowser : fallback_.XmlChildOptimizeForBrowser;
end;

function WebSettings.WriteXmlChildOptimizeForBrowser(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildOptimizeForBrowser) then
            {self.}RemoveChild({self.}XmlChildOptimizeForBrowser);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildOptimizeForBrowser := _value;
        container_.Set({self.}XmlChildOptimizeForBrowser);
    end
    else begin
        raise "Invalid assignment: OptimizeForBrowser expects nil or OpenXmlSimpleType";
    end
end;

function WebSettings.ReadXmlChildAllowPNG();
begin
    if tslassigning and (ifnil({self.}XmlChildAllowPNG) or {self.}XmlChildAllowPNG.Removed) then
    begin
        {self.}XmlChildAllowPNG := new OpenXmlSimpleType(self, {self.}Prefix, "allowPNG");
        container_.Set({self.}XmlChildAllowPNG);
    end
    return {self.}XmlChildAllowPNG and not {self.}XmlChildAllowPNG.Removed ? {self.}XmlChildAllowPNG : fallback_.XmlChildAllowPNG;
end;

function WebSettings.WriteXmlChildAllowPNG(_value: nil_or_OpenXmlSimpleType);
begin
    if ifnil(_value) then
    begin
        if ifObj({self.}XmlChildAllowPNG) then
            {self.}RemoveChild({self.}XmlChildAllowPNG);
    end
    else if _value is class(OpenXmlSimpleType) then
    begin
        {self.}XmlChildAllowPNG := _value;
        container_.Set({self.}XmlChildAllowPNG);
    end
    else begin
        raise "Invalid assignment: AllowPNG expects nil or OpenXmlSimpleType";
    end
end;

function AlternateContent.Create();overload;
begin
    {self.}Create(nil, "mc", "AlternateContent");
end;

function AlternateContent.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function AlternateContent.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function AlternateContent.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "Choice": array(0, makeweakref(thisFunction(ReadXmlChildChoice))),
        pre + "Fallback": array(1, makeweakref(thisFunction(ReadXmlChildFallback))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function AlternateContent.Copy(_obj: AlternateContent);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildChoice) then
        {self.}Choice.Copy(_obj.XmlChildChoice);
    if not ifnil(_obj.XmlChildFallback) then
        {self.}Fallback.Copy(_obj.XmlChildFallback);
    tslassigning := tslassigning_backup;
end;

function AlternateContent.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildChoice) then
        {self.}XmlChildChoice.ConvertToPoint();
    if not ifnil({self.}XmlChildFallback) then
        {self.}XmlChildFallback.ConvertToPoint();
end;

function AlternateContent.ReadXmlChildChoice(): Choice;
begin
    if tslassigning and (ifnil({self.}XmlChildChoice) or {self.}XmlChildChoice.Removed) then
    begin
        {self.}XmlChildChoice := new Choice(self, {self.}Prefix, "Choice");
        container_.Set({self.}XmlChildChoice);
    end
    return {self.}XmlChildChoice and not {self.}XmlChildChoice.Removed ? {self.}XmlChildChoice : fallback_.XmlChildChoice;
end;

function AlternateContent.WriteXmlChildChoice(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildChoice) then
            {self.}RemoveChild({self.}XmlChildChoice);
    end
    else if v is class(Choice) then
    begin
        {self.}XmlChildChoice := v;
        container_.Set({self.}XmlChildChoice);
    end
    else begin
        raise "Invalid assignment: Choice expects Choice or nil";
    end
end;

function AlternateContent.ReadXmlChildFallback(): Fallback;
begin
    if tslassigning and (ifnil({self.}XmlChildFallback) or {self.}XmlChildFallback.Removed) then
    begin
        {self.}XmlChildFallback := new Fallback(self, {self.}Prefix, "Fallback");
        container_.Set({self.}XmlChildFallback);
    end
    return {self.}XmlChildFallback and not {self.}XmlChildFallback.Removed ? {self.}XmlChildFallback : fallback_.XmlChildFallback;
end;

function AlternateContent.WriteXmlChildFallback(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildFallback) then
            {self.}RemoveChild({self.}XmlChildFallback);
    end
    else if v is class(Fallback) then
    begin
        {self.}XmlChildFallback := v;
        container_.Set({self.}XmlChildFallback);
    end
    else begin
        raise "Invalid assignment: Fallback expects Fallback or nil";
    end
end;

function Choice.Create();overload;
begin
    {self.}Create(nil, "mc", "Choice");
end;

function Choice.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Choice.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Choice.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "Requires": makeweakref(thisFunction(WriteXmlAttrRequires)),
    );
    sorted_child_ := array(
        "c14:style": array(0, makeweakref(thisFunction(ReadXmlChildStyle))),
        "w:drawing": array(1, makeweakref(thisFunction(ReadXmlChildDrawing))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Choice.Copy(_obj: Choice);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Requires) then
        {self.}Requires := _obj.Requires;
    if not ifnil(_obj.XmlChildStyle) then
        {self.}Style.Copy(_obj.XmlChildStyle);
    if not ifnil(_obj.XmlChildDrawing) then
        {self.}Drawing.Copy(_obj.XmlChildDrawing);
    tslassigning := tslassigning_backup;
end;

function Choice.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildStyle) then
        {self.}XmlChildStyle.ConvertToPoint();
    if not ifnil({self.}XmlChildDrawing) then
        {self.}XmlChildDrawing.ConvertToPoint();
end;

function Choice.ReadXmlAttrRequires();
begin
    return ifnil({self.}XmlAttrRequires.Value) ? fallback_.XmlAttrRequires.Value : {self.}XmlAttrRequires.Value;
end;

function Choice.WriteXmlAttrRequires(_value: any);
begin
    if ifnil({self.}XmlAttrRequires) then
    begin
        {self.}XmlAttrRequires := new OpenXmlAttribute("", "Requires", nil);
        attributes_["Requires"] := {self.}XmlAttrRequires;
    end
    {self.}XmlAttrRequires.Value := _value;
end;

function Choice.ReadXmlChildStyle(): PureVal;
begin
    if tslassigning and (ifnil({self.}XmlChildStyle) or {self.}XmlChildStyle.Removed) then
    begin
        {self.}XmlChildStyle := new PureVal(self, "c14", "style");
        container_.Set({self.}XmlChildStyle);
    end
    return {self.}XmlChildStyle and not {self.}XmlChildStyle.Removed ? {self.}XmlChildStyle : fallback_.XmlChildStyle;
end;

function Choice.WriteXmlChildStyle(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildStyle) then
            {self.}RemoveChild({self.}XmlChildStyle);
    end
    else if v is class(PureVal) then
    begin
        {self.}XmlChildStyle := v;
        container_.Set({self.}XmlChildStyle);
    end
    else begin
        raise "Invalid assignment: Style expects PureVal or nil";
    end
end;

function Choice.ReadXmlChildDrawing(): Drawing;
begin
    if tslassigning and (ifnil({self.}XmlChildDrawing) or {self.}XmlChildDrawing.Removed) then
    begin
        {self.}XmlChildDrawing := new Drawing(self, "w", "drawing");
        container_.Set({self.}XmlChildDrawing);
    end
    return {self.}XmlChildDrawing and not {self.}XmlChildDrawing.Removed ? {self.}XmlChildDrawing : fallback_.XmlChildDrawing;
end;

function Choice.WriteXmlChildDrawing(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildDrawing) then
            {self.}RemoveChild({self.}XmlChildDrawing);
    end
    else if v is class(Drawing) then
    begin
        {self.}XmlChildDrawing := v;
        container_.Set({self.}XmlChildDrawing);
    end
    else begin
        raise "Invalid assignment: Drawing expects Drawing or nil";
    end
end;

function Fallback.Create();overload;
begin
    {self.}Create(nil, "mc", "Fallback");
end;

function Fallback.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Fallback.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Fallback.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        "c:style": array(0, makeweakref(thisFunction(ReadXmlChildStyle))),
        "w:pict": array(1, makeweakref(thisFunction(ReadXmlChildPict))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Fallback.Copy(_obj: Fallback);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildStyle) then
        {self.}Style.Copy(_obj.XmlChildStyle);
    if not ifnil(_obj.XmlChildPict) then
        {self.}Pict.Copy(_obj.XmlChildPict);
    tslassigning := tslassigning_backup;
end;

function Fallback.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildStyle) then
        {self.}XmlChildStyle.ConvertToPoint();
    if not ifnil({self.}XmlChildPict) then
        {self.}XmlChildPict.ConvertToPoint();
end;

function Fallback.ReadXmlChildStyle(): PureVal;
begin
    if tslassigning and (ifnil({self.}XmlChildStyle) or {self.}XmlChildStyle.Removed) then
    begin
        {self.}XmlChildStyle := new PureVal(self, "c", "style");
        container_.Set({self.}XmlChildStyle);
    end
    return {self.}XmlChildStyle and not {self.}XmlChildStyle.Removed ? {self.}XmlChildStyle : fallback_.XmlChildStyle;
end;

function Fallback.WriteXmlChildStyle(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildStyle) then
            {self.}RemoveChild({self.}XmlChildStyle);
    end
    else if v is class(PureVal) then
    begin
        {self.}XmlChildStyle := v;
        container_.Set({self.}XmlChildStyle);
    end
    else begin
        raise "Invalid assignment: Style expects PureVal or nil";
    end
end;

function Fallback.ReadXmlChildPict(): Pict;
begin
    if tslassigning and (ifnil({self.}XmlChildPict) or {self.}XmlChildPict.Removed) then
    begin
        {self.}XmlChildPict := new Pict(self, "w", "pict");
        container_.Set({self.}XmlChildPict);
    end
    return {self.}XmlChildPict and not {self.}XmlChildPict.Removed ? {self.}XmlChildPict : fallback_.XmlChildPict;
end;

function Fallback.WriteXmlChildPict(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPict) then
            {self.}RemoveChild({self.}XmlChildPict);
    end
    else if v is class(Pict) then
    begin
        {self.}XmlChildPict := v;
        container_.Set({self.}XmlChildPict);
    end
    else begin
        raise "Invalid assignment: Pict expects Pict or nil";
    end
end;

function Pict.Create();overload;
begin
    {self.}Create(nil, "w", "pict");
end;

function Pict.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Pict.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Pict.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        "v:shapetype": array(0, makeweakref(thisFunction(ReadXmlChildShapetype))),
        "v:shape": array(1, makeweakref(thisFunction(ReadXmlChildShape))),
        "v:control": array(2, makeweakref(thisFunction(ReadXmlChildControl))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Pict.Copy(_obj: Pict);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildShapetype) then
        {self.}Shapetype.Copy(_obj.XmlChildShapetype);
    if not ifnil(_obj.XmlChildShape) then
        {self.}Shape.Copy(_obj.XmlChildShape);
    if not ifnil(_obj.XmlChildControl) then
        {self.}Control.Copy(_obj.XmlChildControl);
    tslassigning := tslassigning_backup;
end;

function Pict.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildShapetype) then
        {self.}XmlChildShapetype.ConvertToPoint();
    if not ifnil({self.}XmlChildShape) then
        {self.}XmlChildShape.ConvertToPoint();
    if not ifnil({self.}XmlChildControl) then
        {self.}XmlChildControl.ConvertToPoint();
end;

function Pict.ReadXmlChildShapetype(): Shapetype;
begin
    if tslassigning and (ifnil({self.}XmlChildShapetype) or {self.}XmlChildShapetype.Removed) then
    begin
        {self.}XmlChildShapetype := new VML.Shapetype(self, "v", "shapetype");
        container_.Set({self.}XmlChildShapetype);
    end
    return {self.}XmlChildShapetype and not {self.}XmlChildShapetype.Removed ? {self.}XmlChildShapetype : fallback_.XmlChildShapetype;
end;

function Pict.WriteXmlChildShapetype(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildShapetype) then
            {self.}RemoveChild({self.}XmlChildShapetype);
    end
    else if v is class(Shapetype) then
    begin
        {self.}XmlChildShapetype := v;
        container_.Set({self.}XmlChildShapetype);
    end
    else begin
        raise "Invalid assignment: Shapetype expects Shapetype or nil";
    end
end;

function Pict.ReadXmlChildShape(): Shape;
begin
    if tslassigning and (ifnil({self.}XmlChildShape) or {self.}XmlChildShape.Removed) then
    begin
        {self.}XmlChildShape := new VML.Shape(self, "v", "shape");
        container_.Set({self.}XmlChildShape);
    end
    return {self.}XmlChildShape and not {self.}XmlChildShape.Removed ? {self.}XmlChildShape : fallback_.XmlChildShape;
end;

function Pict.WriteXmlChildShape(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildShape) then
            {self.}RemoveChild({self.}XmlChildShape);
    end
    else if v is class(Shape) then
    begin
        {self.}XmlChildShape := v;
        container_.Set({self.}XmlChildShape);
    end
    else begin
        raise "Invalid assignment: Shape expects Shape or nil";
    end
end;

function Pict.ReadXmlChildControl(): Control;
begin
    if tslassigning and (ifnil({self.}XmlChildControl) or {self.}XmlChildControl.Removed) then
    begin
        {self.}XmlChildControl := new Control(self, "v", "control");
        container_.Set({self.}XmlChildControl);
    end
    return {self.}XmlChildControl and not {self.}XmlChildControl.Removed ? {self.}XmlChildControl : fallback_.XmlChildControl;
end;

function Pict.WriteXmlChildControl(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildControl) then
            {self.}RemoveChild({self.}XmlChildControl);
    end
    else if v is class(Control) then
    begin
        {self.}XmlChildControl := v;
        container_.Set({self.}XmlChildControl);
    end
    else begin
        raise "Invalid assignment: Control expects Control or nil";
    end
end;

function Control.Create();overload;
begin
    {self.}Create(nil, "w", "control");
end;

function Control.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Control.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Control.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "r:id": makeweakref(thisFunction(WriteXmlAttrId)),
        pre + "shapeid": makeweakref(thisFunction(WriteXmlAttrShapeid)),
        pre + "name": makeweakref(thisFunction(WriteXmlAttrname)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Control.Copy(_obj: Control);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Id) then
        {self.}Id := _obj.Id;
    if not ifnil(_obj.Shapeid) then
        {self.}Shapeid := _obj.Shapeid;
    if not ifnil(_obj.name) then
        {self.}name := _obj.name;
    tslassigning := tslassigning_backup;
end;

function Control.ConvertToPoint();override;
begin

end;

function Control.ReadXmlAttrId();
begin
    return ifnil({self.}XmlAttrId.Value) ? fallback_.XmlAttrId.Value : {self.}XmlAttrId.Value;
end;

function Control.WriteXmlAttrId(_value: any);
begin
    if ifnil({self.}XmlAttrId) then
    begin
        {self.}XmlAttrId := new OpenXmlAttribute("r", "id", nil);
        attributes_["r:id"] := {self.}XmlAttrId;
    end
    {self.}XmlAttrId.Value := _value;
end;

function Control.ReadXmlAttrShapeid();
begin
    return ifnil({self.}XmlAttrShapeid.Value) ? fallback_.XmlAttrShapeid.Value : {self.}XmlAttrShapeid.Value;
end;

function Control.WriteXmlAttrShapeid(_value: any);
begin
    if ifnil({self.}XmlAttrShapeid) then
    begin
        {self.}XmlAttrShapeid := new OpenXmlAttribute({self.}Prefix, "shapeid", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "shapeid" : "shapeid"] := {self.}XmlAttrShapeid;
    end
    {self.}XmlAttrShapeid.Value := _value;
end;

function Control.ReadXmlAttrname();
begin
    return ifnil({self.}XmlAttrname.Value) ? fallback_.XmlAttrname.Value : {self.}XmlAttrname.Value;
end;

function Control.WriteXmlAttrname(_value: any);
begin
    if ifnil({self.}XmlAttrname) then
    begin
        {self.}XmlAttrname := new OpenXmlAttribute({self.}Prefix, "name", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "name" : "name"] := {self.}XmlAttrname;
    end
    {self.}XmlAttrname.Value := _value;
end;

function Ftr.Create();overload;
begin
    {self.}Create(nil, "w", "ftr");
end;

function Ftr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Ftr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Ftr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "mc:Ignorable": makeweakref(thisFunction(WriteXmlAttrIgnorable)),
    );
    sorted_child_ := array(
        pre + "p": array(0, makeweakref(thisFunction(AppendP))),
        pre + "sdt": array(1, makeweakref(thisFunction(ReadXmlChildSdt))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Ftr.Copy(_obj: Ftr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Ignorable) then
        {self.}Ignorable := _obj.Ignorable;
    if not ifnil(_obj.XmlChildSdt) then
        {self.}Sdt.Copy(_obj.XmlChildSdt);
    tslassigning := tslassigning_backup;
end;

function Ftr.ConvertToPoint();override;
begin
    elems := {self.}Ps();
    for _,elem in elems do
        elem.ConvertToPoint();
    if not ifnil({self.}XmlChildSdt) then
        {self.}XmlChildSdt.ConvertToPoint();
end;

function Ftr.ReadXmlAttrIgnorable();
begin
    return ifnil({self.}XmlAttrIgnorable.Value) ? fallback_.XmlAttrIgnorable.Value : {self.}XmlAttrIgnorable.Value;
end;

function Ftr.WriteXmlAttrIgnorable(_value: any);
begin
    if ifnil({self.}XmlAttrIgnorable) then
    begin
        {self.}XmlAttrIgnorable := new OpenXmlAttribute("mc", "Ignorable", nil);
        attributes_["mc:Ignorable"] := {self.}XmlAttrIgnorable;
    end
    {self.}XmlAttrIgnorable.Value := _value;
end;

function Ftr.ReadXmlChildSdt(): Sdt;
begin
    if tslassigning and (ifnil({self.}XmlChildSdt) or {self.}XmlChildSdt.Removed) then
    begin
        {self.}XmlChildSdt := new Sdt(self, {self.}Prefix, "sdt");
        container_.Set({self.}XmlChildSdt);
    end
    return {self.}XmlChildSdt and not {self.}XmlChildSdt.Removed ? {self.}XmlChildSdt : fallback_.XmlChildSdt;
end;

function Ftr.WriteXmlChildSdt(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildSdt) then
            {self.}RemoveChild({self.}XmlChildSdt);
    end
    else if v is class(Sdt) then
    begin
        {self.}XmlChildSdt := v;
        container_.Set({self.}XmlChildSdt);
    end
    else begin
        raise "Invalid assignment: Sdt expects Sdt or nil";
    end
end;

function Ftr.ReadPs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "p", ind);
end;

function Ftr.WritePs(_index: integer; _value: nil_OR_P);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadPs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "p", ind, _value) then
            raise format("Index out of range: Ps[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Ps expects nil or P";
    end
end;

function Ftr.AddP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Insert(obj);
    return obj;
end;

function Ftr.AppendP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Append(obj);
    return obj;
end;

function Hdr.Create();overload;
begin
    {self.}Create(nil, "w", "hdr");
end;

function Hdr.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Hdr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Hdr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "mc:Ignorable": makeweakref(thisFunction(WriteXmlAttrIgnorable)),
    );
    sorted_child_ := array(
        pre + "p": array(0, makeweakref(thisFunction(AppendP))),
        pre + "sdt": array(1, makeweakref(thisFunction(ReadXmlChildSdt))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Hdr.Copy(_obj: Hdr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Ignorable) then
        {self.}Ignorable := _obj.Ignorable;
    if not ifnil(_obj.XmlChildSdt) then
        {self.}Sdt.Copy(_obj.XmlChildSdt);
    tslassigning := tslassigning_backup;
end;

function Hdr.ConvertToPoint();override;
begin
    elems := {self.}Ps();
    for _,elem in elems do
        elem.ConvertToPoint();
    if not ifnil({self.}XmlChildSdt) then
        {self.}XmlChildSdt.ConvertToPoint();
end;

function Hdr.ReadXmlAttrIgnorable();
begin
    return ifnil({self.}XmlAttrIgnorable.Value) ? fallback_.XmlAttrIgnorable.Value : {self.}XmlAttrIgnorable.Value;
end;

function Hdr.WriteXmlAttrIgnorable(_value: any);
begin
    if ifnil({self.}XmlAttrIgnorable) then
    begin
        {self.}XmlAttrIgnorable := new OpenXmlAttribute("mc", "Ignorable", nil);
        attributes_["mc:Ignorable"] := {self.}XmlAttrIgnorable;
    end
    {self.}XmlAttrIgnorable.Value := _value;
end;

function Hdr.ReadXmlChildSdt(): Sdt;
begin
    if tslassigning and (ifnil({self.}XmlChildSdt) or {self.}XmlChildSdt.Removed) then
    begin
        {self.}XmlChildSdt := new Sdt(self, {self.}Prefix, "sdt");
        container_.Set({self.}XmlChildSdt);
    end
    return {self.}XmlChildSdt and not {self.}XmlChildSdt.Removed ? {self.}XmlChildSdt : fallback_.XmlChildSdt;
end;

function Hdr.WriteXmlChildSdt(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildSdt) then
            {self.}RemoveChild({self.}XmlChildSdt);
    end
    else if v is class(Sdt) then
    begin
        {self.}XmlChildSdt := v;
        container_.Set({self.}XmlChildSdt);
    end
    else begin
        raise "Invalid assignment: Sdt expects Sdt or nil";
    end
end;

function Hdr.ReadPs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "p", ind);
end;

function Hdr.WritePs(_index: integer; _value: nil_OR_P);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadPs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "p", ind, _value) then
            raise format("Index out of range: Ps[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Ps expects nil or P";
    end
end;

function Hdr.AddP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Insert(obj);
    return obj;
end;

function Hdr.AppendP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Append(obj);
    return obj;
end;

function Comments.Create();overload;
begin
    {self.}Create(nil, "w", "comments");
end;

function Comments.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Comments.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Comments.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "mc:Ignorable": makeweakref(thisFunction(WriteXmlAttrIgnorable)),
    );
    sorted_child_ := array(
        pre + "comment": array(0, makeweakref(thisFunction(AppendComment))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Comments.Copy(_obj: Comments);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Ignorable) then
        {self.}Ignorable := _obj.Ignorable;
    tslassigning := tslassigning_backup;
end;

function Comments.ConvertToPoint();override;
begin
    elems := {self.}Comments();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Comments.ReadXmlAttrIgnorable();
begin
    return ifnil({self.}XmlAttrIgnorable.Value) ? fallback_.XmlAttrIgnorable.Value : {self.}XmlAttrIgnorable.Value;
end;

function Comments.WriteXmlAttrIgnorable(_value: any);
begin
    if ifnil({self.}XmlAttrIgnorable) then
    begin
        {self.}XmlAttrIgnorable := new OpenXmlAttribute("mc", "Ignorable", nil);
        attributes_["mc:Ignorable"] := {self.}XmlAttrIgnorable;
    end
    {self.}XmlAttrIgnorable.Value := _value;
end;

function Comments.ReadComments(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "comment", ind);
end;

function Comments.WriteComments(_index: integer; _value: nil_OR_Comment);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadComments(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "comment", ind, _value) then
            raise format("Index out of range: Comments[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Comments expects nil or Comment";
    end
end;

function Comments.AddComment(): Comment;
begin
    obj := new Comment(self, {self.}Prefix, "comment");
    container_.Insert(obj);
    return obj;
end;

function Comments.AppendComment(): Comment;
begin
    obj := new Comment(self, {self.}Prefix, "comment");
    container_.Append(obj);
    return obj;
end;

function Comment.Create();overload;
begin
    {self.}Create(nil, "w", "comment");
end;

function Comment.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Comment.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Comment.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "author": makeweakref(thisFunction(WriteXmlAttrAuthor)),
        pre + "date": makeweakref(thisFunction(WriteXmlAttrDate)),
        pre + "id": makeweakref(thisFunction(WriteXmlAttrId)),
    );
    sorted_child_ := array(
        pre + "p": array(0, makeweakref(thisFunction(AppendP))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Comment.Copy(_obj: Comment);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Author) then
        {self.}Author := _obj.Author;
    if not ifnil(_obj.Date) then
        {self.}Date := _obj.Date;
    if not ifnil(_obj.Id) then
        {self.}Id := _obj.Id;
    tslassigning := tslassigning_backup;
end;

function Comment.ConvertToPoint();override;
begin
    elems := {self.}Ps();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Comment.ReadXmlAttrAuthor();
begin
    return ifnil({self.}XmlAttrAuthor.Value) ? fallback_.XmlAttrAuthor.Value : {self.}XmlAttrAuthor.Value;
end;

function Comment.WriteXmlAttrAuthor(_value: any);
begin
    if ifnil({self.}XmlAttrAuthor) then
    begin
        {self.}XmlAttrAuthor := new OpenXmlAttribute({self.}Prefix, "author", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "author" : "author"] := {self.}XmlAttrAuthor;
    end
    {self.}XmlAttrAuthor.Value := _value;
end;

function Comment.ReadXmlAttrDate();
begin
    return ifnil({self.}XmlAttrDate.Value) ? fallback_.XmlAttrDate.Value : {self.}XmlAttrDate.Value;
end;

function Comment.WriteXmlAttrDate(_value: any);
begin
    if ifnil({self.}XmlAttrDate) then
    begin
        {self.}XmlAttrDate := new OpenXmlAttribute({self.}Prefix, "date", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "date" : "date"] := {self.}XmlAttrDate;
    end
    {self.}XmlAttrDate.Value := _value;
end;

function Comment.ReadXmlAttrId();
begin
    return ifnil({self.}XmlAttrId.Value) ? fallback_.XmlAttrId.Value : {self.}XmlAttrId.Value;
end;

function Comment.WriteXmlAttrId(_value: any);
begin
    if ifnil({self.}XmlAttrId) then
    begin
        {self.}XmlAttrId := new OpenXmlAttribute({self.}Prefix, "id", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "id" : "id"] := {self.}XmlAttrId;
    end
    {self.}XmlAttrId.Value := _value;
end;

function Comment.ReadPs(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "p", ind);
end;

function Comment.WritePs(_index: integer; _value: nil_OR_P);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadPs(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "p", ind, _value) then
            raise format("Index out of range: Ps[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Ps expects nil or P";
    end
end;

function Comment.AddP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Insert(obj);
    return obj;
end;

function Comment.AppendP(): P;
begin
    obj := new P(self, {self.}Prefix, "p");
    container_.Append(obj);
    return obj;
end;

function Numbering.Create();overload;
begin
    {self.}Create(nil, "w", "numbering");
end;

function Numbering.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Numbering.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Numbering.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "mc:Ignorable": makeweakref(thisFunction(WriteXmlAttrIgnorable)),
    );
    sorted_child_ := array(
        pre + "abstractNum": array(0, makeweakref(thisFunction(AppendAbstractNum))),
        pre + "num": array(1, makeweakref(thisFunction(AppendNum))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Numbering.Copy(_obj: Numbering);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Ignorable) then
        {self.}Ignorable := _obj.Ignorable;
    tslassigning := tslassigning_backup;
end;

function Numbering.ConvertToPoint();override;
begin
    elems := {self.}AbstractNums();
    for _,elem in elems do
        elem.ConvertToPoint();
    elems := {self.}Nums();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function Numbering.ReadXmlAttrIgnorable();
begin
    return ifnil({self.}XmlAttrIgnorable.Value) ? fallback_.XmlAttrIgnorable.Value : {self.}XmlAttrIgnorable.Value;
end;

function Numbering.WriteXmlAttrIgnorable(_value: any);
begin
    if ifnil({self.}XmlAttrIgnorable) then
    begin
        {self.}XmlAttrIgnorable := new OpenXmlAttribute("mc", "Ignorable", nil);
        attributes_["mc:Ignorable"] := {self.}XmlAttrIgnorable;
    end
    {self.}XmlAttrIgnorable.Value := _value;
end;

function Numbering.ReadAbstractNums(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "abstractNum", ind);
end;

function Numbering.WriteAbstractNums(_index: integer; _value: nil_OR_AbstractNum);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadAbstractNums(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "abstractNum", ind, _value) then
            raise format("Index out of range: AbstractNums[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: AbstractNums expects nil or AbstractNum";
    end
end;

function Numbering.ReadNums(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "num", ind);
end;

function Numbering.WriteNums(_index: integer; _value: nil_OR_Num);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadNums(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "num", ind, _value) then
            raise format("Index out of range: Nums[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Nums expects nil or Num";
    end
end;

function Numbering.AddAbstractNum(): AbstractNum;
begin
    obj := new AbstractNum(self, {self.}Prefix, "abstractNum");
    container_.Insert(obj);
    return obj;
end;

function Numbering.AddNum(): Num;
begin
    obj := new Num(self, {self.}Prefix, "num");
    container_.Insert(obj);
    return obj;
end;

function Numbering.AppendAbstractNum(): AbstractNum;
begin
    obj := new AbstractNum(self, {self.}Prefix, "abstractNum");
    container_.Append(obj);
    return obj;
end;

function Numbering.AppendNum(): Num;
begin
    obj := new Num(self, {self.}Prefix, "num");
    container_.Append(obj);
    return obj;
end;

function Num.Create();overload;
begin
    {self.}Create(nil, "w", "num");
end;

function Num.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Num.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Num.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "numId": makeweakref(thisFunction(WriteXmlAttrNumId)),
    );
    sorted_child_ := array(
        pre + "abstractNumId": array(0, makeweakref(thisFunction(ReadXmlChildAbstractNumId))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Num.Copy(_obj: Num);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.NumId) then
        {self.}NumId := _obj.NumId;
    if not ifnil(_obj.XmlChildAbstractNumId) then
        {self.}AbstractNumId.Copy(_obj.XmlChildAbstractNumId);
    tslassigning := tslassigning_backup;
end;

function Num.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildAbstractNumId) then
        {self.}XmlChildAbstractNumId.ConvertToPoint();
end;

function Num.ReadXmlAttrNumId();
begin
    return ifnil({self.}XmlAttrNumId.Value) ? fallback_.XmlAttrNumId.Value : {self.}XmlAttrNumId.Value;
end;

function Num.WriteXmlAttrNumId(_value: any);
begin
    if ifnil({self.}XmlAttrNumId) then
    begin
        {self.}XmlAttrNumId := new OpenXmlAttribute({self.}Prefix, "numId", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "numId" : "numId"] := {self.}XmlAttrNumId;
    end
    {self.}XmlAttrNumId.Value := _value;
end;

function Num.ReadXmlChildAbstractNumId(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildAbstractNumId) or {self.}XmlChildAbstractNumId.Removed) then
    begin
        {self.}XmlChildAbstractNumId := new PureWVal(self, {self.}Prefix, "abstractNumId");
        container_.Set({self.}XmlChildAbstractNumId);
    end
    return {self.}XmlChildAbstractNumId and not {self.}XmlChildAbstractNumId.Removed ? {self.}XmlChildAbstractNumId : fallback_.XmlChildAbstractNumId;
end;

function Num.WriteXmlChildAbstractNumId(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildAbstractNumId) then
            {self.}RemoveChild({self.}XmlChildAbstractNumId);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildAbstractNumId := v;
        container_.Set({self.}XmlChildAbstractNumId);
    end
    else begin
        raise "Invalid assignment: AbstractNumId expects PureWVal or nil";
    end
end;

function AbstractNum.Create();overload;
begin
    {self.}Create(nil, "w", "abstractNum");
end;

function AbstractNum.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function AbstractNum.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function AbstractNum.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "abstractNumId": makeweakref(thisFunction(WriteXmlAttrAbstractNumId)),
        pre + "restartNumberingAfterBreak": makeweakref(thisFunction(WriteXmlAttrRestartNumberingAfterBreak)),
    );
    sorted_child_ := array(
        pre + "nsid": array(0, makeweakref(thisFunction(ReadXmlChildNsid))),
        pre + "multiLevelType": array(1, makeweakref(thisFunction(ReadXmlChildMultiLevelType))),
        pre + "tmpl": array(2, makeweakref(thisFunction(ReadXmlChildTmpl))),
        pre + "lvl": array(3, makeweakref(thisFunction(AppendLvl))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function AbstractNum.Copy(_obj: AbstractNum);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.AbstractNumId) then
        {self.}AbstractNumId := _obj.AbstractNumId;
    if not ifnil(_obj.RestartNumberingAfterBreak) then
        {self.}RestartNumberingAfterBreak := _obj.RestartNumberingAfterBreak;
    if not ifnil(_obj.XmlChildNsid) then
        {self.}Nsid.Copy(_obj.XmlChildNsid);
    if not ifnil(_obj.XmlChildMultiLevelType) then
        {self.}MultiLevelType.Copy(_obj.XmlChildMultiLevelType);
    if not ifnil(_obj.XmlChildTmpl) then
        {self.}Tmpl.Copy(_obj.XmlChildTmpl);
    tslassigning := tslassigning_backup;
end;

function AbstractNum.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildNsid) then
        {self.}XmlChildNsid.ConvertToPoint();
    if not ifnil({self.}XmlChildMultiLevelType) then
        {self.}XmlChildMultiLevelType.ConvertToPoint();
    if not ifnil({self.}XmlChildTmpl) then
        {self.}XmlChildTmpl.ConvertToPoint();
    elems := {self.}Lvls();
    for _,elem in elems do
        elem.ConvertToPoint();
end;

function AbstractNum.ReadXmlAttrAbstractNumId();
begin
    return ifnil({self.}XmlAttrAbstractNumId.Value) ? fallback_.XmlAttrAbstractNumId.Value : {self.}XmlAttrAbstractNumId.Value;
end;

function AbstractNum.WriteXmlAttrAbstractNumId(_value: any);
begin
    if ifnil({self.}XmlAttrAbstractNumId) then
    begin
        {self.}XmlAttrAbstractNumId := new OpenXmlAttribute({self.}Prefix, "abstractNumId", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "abstractNumId" : "abstractNumId"] := {self.}XmlAttrAbstractNumId;
    end
    {self.}XmlAttrAbstractNumId.Value := _value;
end;

function AbstractNum.ReadXmlAttrRestartNumberingAfterBreak();
begin
    return ifnil({self.}XmlAttrRestartNumberingAfterBreak.Value) ? fallback_.XmlAttrRestartNumberingAfterBreak.Value : {self.}XmlAttrRestartNumberingAfterBreak.Value;
end;

function AbstractNum.WriteXmlAttrRestartNumberingAfterBreak(_value: any);
begin
    if ifnil({self.}XmlAttrRestartNumberingAfterBreak) then
    begin
        {self.}XmlAttrRestartNumberingAfterBreak := new OpenXmlAttribute({self.}Prefix, "restartNumberingAfterBreak", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "restartNumberingAfterBreak" : "restartNumberingAfterBreak"] := {self.}XmlAttrRestartNumberingAfterBreak;
    end
    {self.}XmlAttrRestartNumberingAfterBreak.Value := _value;
end;

function AbstractNum.ReadXmlChildNsid(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildNsid) or {self.}XmlChildNsid.Removed) then
    begin
        {self.}XmlChildNsid := new PureWVal(self, {self.}Prefix, "nsid");
        container_.Set({self.}XmlChildNsid);
    end
    return {self.}XmlChildNsid and not {self.}XmlChildNsid.Removed ? {self.}XmlChildNsid : fallback_.XmlChildNsid;
end;

function AbstractNum.WriteXmlChildNsid(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildNsid) then
            {self.}RemoveChild({self.}XmlChildNsid);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildNsid := v;
        container_.Set({self.}XmlChildNsid);
    end
    else begin
        raise "Invalid assignment: Nsid expects PureWVal or nil";
    end
end;

function AbstractNum.ReadXmlChildMultiLevelType(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildMultiLevelType) or {self.}XmlChildMultiLevelType.Removed) then
    begin
        {self.}XmlChildMultiLevelType := new PureWVal(self, {self.}Prefix, "multiLevelType");
        container_.Set({self.}XmlChildMultiLevelType);
    end
    return {self.}XmlChildMultiLevelType and not {self.}XmlChildMultiLevelType.Removed ? {self.}XmlChildMultiLevelType : fallback_.XmlChildMultiLevelType;
end;

function AbstractNum.WriteXmlChildMultiLevelType(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildMultiLevelType) then
            {self.}RemoveChild({self.}XmlChildMultiLevelType);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildMultiLevelType := v;
        container_.Set({self.}XmlChildMultiLevelType);
    end
    else begin
        raise "Invalid assignment: MultiLevelType expects PureWVal or nil";
    end
end;

function AbstractNum.ReadXmlChildTmpl(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildTmpl) or {self.}XmlChildTmpl.Removed) then
    begin
        {self.}XmlChildTmpl := new PureWVal(self, {self.}Prefix, "tmpl");
        container_.Set({self.}XmlChildTmpl);
    end
    return {self.}XmlChildTmpl and not {self.}XmlChildTmpl.Removed ? {self.}XmlChildTmpl : fallback_.XmlChildTmpl;
end;

function AbstractNum.WriteXmlChildTmpl(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildTmpl) then
            {self.}RemoveChild({self.}XmlChildTmpl);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildTmpl := v;
        container_.Set({self.}XmlChildTmpl);
    end
    else begin
        raise "Invalid assignment: Tmpl expects PureWVal or nil";
    end
end;

function AbstractNum.ReadLvls(_index: integer);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "lvl", ind);
end;

function AbstractNum.WriteLvls(_index: integer; _value: nil_OR_Lvl);
begin
    if ifnil(_value) then
    begin
        obj := {self.}ReadLvls(_index);
        {self.}RemoveChild(obj);
    end
    else if ifInt(_index) or ifInt64(_index) then
    begin
        ind := ifnil(_index) ? -2 : _index;
        pre := {self.}Prefix ? {self.}Prefix + ":" : "";
        if not container_.Set(pre + "lvl", ind, _value) then
            raise format("Index out of range: Lvls[%d] is invalid or out of bounds", _index);
    end
    else begin
        raise "Invalid assignment: Lvls expects nil or Lvl";
    end
end;

function AbstractNum.AddLvl(): Lvl;
begin
    obj := new Lvl(self, {self.}Prefix, "lvl");
    container_.Insert(obj);
    return obj;
end;

function AbstractNum.AppendLvl(): Lvl;
begin
    obj := new Lvl(self, {self.}Prefix, "lvl");
    container_.Append(obj);
    return obj;
end;

function Lvl.Create();overload;
begin
    {self.}Create(nil, "w", "lvl");
end;

function Lvl.Create(_node: XmlNode);overload;
begin
    inherited Create(_node: XmlNode);
end;

function Lvl.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    inherited Create(_parent, _prefix, _local_name);
end;

function Lvl.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "ilvl": makeweakref(thisFunction(WriteXmlAttrIlvl)),
        pre + "tentative": makeweakref(thisFunction(WriteXmlAttrTentative)),
    );
    sorted_child_ := array(
        pre + "start": array(0, makeweakref(thisFunction(ReadXmlChildStart))),
        pre + "numFmt": array(1, makeweakref(thisFunction(ReadXmlChildNumFmt))),
        pre + "pStyle": array(2, makeweakref(thisFunction(ReadXmlChildPStyle))),
        pre + "suff": array(3, makeweakref(thisFunction(ReadXmlChildSuff))),
        pre + "lvlText": array(4, makeweakref(thisFunction(ReadXmlChildLvlText))),
        pre + "lvlJc": array(5, makeweakref(thisFunction(ReadXmlChildLvlJc))),
        pre + "pPr": array(6, makeweakref(thisFunction(ReadXmlChildPPr))),
        pre + "rPr": array(7, makeweakref(thisFunction(ReadXmlChildRPr))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Lvl.Copy(_obj: Lvl);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.Ilvl) then
        {self.}Ilvl := _obj.Ilvl;
    if not ifnil(_obj.Tentative) then
        {self.}Tentative := _obj.Tentative;
    if not ifnil(_obj.XmlChildStart) then
        {self.}Start.Copy(_obj.XmlChildStart);
    if not ifnil(_obj.XmlChildNumFmt) then
        {self.}NumFmt.Copy(_obj.XmlChildNumFmt);
    if not ifnil(_obj.XmlChildPStyle) then
        {self.}PStyle.Copy(_obj.XmlChildPStyle);
    if not ifnil(_obj.XmlChildSuff) then
        {self.}Suff.Copy(_obj.XmlChildSuff);
    if not ifnil(_obj.XmlChildLvlText) then
        {self.}LvlText.Copy(_obj.XmlChildLvlText);
    if not ifnil(_obj.XmlChildLvlJc) then
        {self.}LvlJc.Copy(_obj.XmlChildLvlJc);
    if not ifnil(_obj.XmlChildPPr) then
        {self.}PPr.Copy(_obj.XmlChildPPr);
    if not ifnil(_obj.XmlChildRPr) then
        {self.}RPr.Copy(_obj.XmlChildRPr);
    tslassigning := tslassigning_backup;
end;

function Lvl.ConvertToPoint();override;
begin
    if not ifnil({self.}XmlChildStart) then
        {self.}XmlChildStart.ConvertToPoint();
    if not ifnil({self.}XmlChildNumFmt) then
        {self.}XmlChildNumFmt.ConvertToPoint();
    if not ifnil({self.}XmlChildPStyle) then
        {self.}XmlChildPStyle.ConvertToPoint();
    if not ifnil({self.}XmlChildSuff) then
        {self.}XmlChildSuff.ConvertToPoint();
    if not ifnil({self.}XmlChildLvlText) then
        {self.}XmlChildLvlText.ConvertToPoint();
    if not ifnil({self.}XmlChildLvlJc) then
        {self.}XmlChildLvlJc.ConvertToPoint();
    if not ifnil({self.}XmlChildPPr) then
        {self.}XmlChildPPr.ConvertToPoint();
    if not ifnil({self.}XmlChildRPr) then
        {self.}XmlChildRPr.ConvertToPoint();
end;

function Lvl.ReadXmlAttrIlvl();
begin
    return ifnil({self.}XmlAttrIlvl.Value) ? fallback_.XmlAttrIlvl.Value : {self.}XmlAttrIlvl.Value;
end;

function Lvl.WriteXmlAttrIlvl(_value: any);
begin
    if ifnil({self.}XmlAttrIlvl) then
    begin
        {self.}XmlAttrIlvl := new OpenXmlAttribute({self.}Prefix, "ilvl", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "ilvl" : "ilvl"] := {self.}XmlAttrIlvl;
    end
    {self.}XmlAttrIlvl.Value := _value;
end;

function Lvl.ReadXmlAttrTentative();
begin
    return ifnil({self.}XmlAttrTentative.Value) ? fallback_.XmlAttrTentative.Value : {self.}XmlAttrTentative.Value;
end;

function Lvl.WriteXmlAttrTentative(_value: any);
begin
    if ifnil({self.}XmlAttrTentative) then
    begin
        {self.}XmlAttrTentative := new OpenXmlAttribute({self.}Prefix, "tentative", nil);
        attributes_[{self.}Prefix ? {self.}Prefix + ":" + "tentative" : "tentative"] := {self.}XmlAttrTentative;
    end
    {self.}XmlAttrTentative.Value := _value;
end;

function Lvl.ReadXmlChildStart(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildStart) or {self.}XmlChildStart.Removed) then
    begin
        {self.}XmlChildStart := new PureWVal(self, {self.}Prefix, "start");
        container_.Set({self.}XmlChildStart);
    end
    return {self.}XmlChildStart and not {self.}XmlChildStart.Removed ? {self.}XmlChildStart : fallback_.XmlChildStart;
end;

function Lvl.WriteXmlChildStart(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildStart) then
            {self.}RemoveChild({self.}XmlChildStart);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildStart := v;
        container_.Set({self.}XmlChildStart);
    end
    else begin
        raise "Invalid assignment: Start expects PureWVal or nil";
    end
end;

function Lvl.ReadXmlChildNumFmt(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildNumFmt) or {self.}XmlChildNumFmt.Removed) then
    begin
        {self.}XmlChildNumFmt := new PureWVal(self, {self.}Prefix, "numFmt");
        container_.Set({self.}XmlChildNumFmt);
    end
    return {self.}XmlChildNumFmt and not {self.}XmlChildNumFmt.Removed ? {self.}XmlChildNumFmt : fallback_.XmlChildNumFmt;
end;

function Lvl.WriteXmlChildNumFmt(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildNumFmt) then
            {self.}RemoveChild({self.}XmlChildNumFmt);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildNumFmt := v;
        container_.Set({self.}XmlChildNumFmt);
    end
    else begin
        raise "Invalid assignment: NumFmt expects PureWVal or nil";
    end
end;

function Lvl.ReadXmlChildPStyle(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildPStyle) or {self.}XmlChildPStyle.Removed) then
    begin
        {self.}XmlChildPStyle := new PureWVal(self, {self.}Prefix, "pStyle");
        container_.Set({self.}XmlChildPStyle);
    end
    return {self.}XmlChildPStyle and not {self.}XmlChildPStyle.Removed ? {self.}XmlChildPStyle : fallback_.XmlChildPStyle;
end;

function Lvl.WriteXmlChildPStyle(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPStyle) then
            {self.}RemoveChild({self.}XmlChildPStyle);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildPStyle := v;
        container_.Set({self.}XmlChildPStyle);
    end
    else begin
        raise "Invalid assignment: PStyle expects PureWVal or nil";
    end
end;

function Lvl.ReadXmlChildSuff(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildSuff) or {self.}XmlChildSuff.Removed) then
    begin
        {self.}XmlChildSuff := new PureWVal(self, {self.}Prefix, "suff");
        container_.Set({self.}XmlChildSuff);
    end
    return {self.}XmlChildSuff and not {self.}XmlChildSuff.Removed ? {self.}XmlChildSuff : fallback_.XmlChildSuff;
end;

function Lvl.WriteXmlChildSuff(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildSuff) then
            {self.}RemoveChild({self.}XmlChildSuff);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildSuff := v;
        container_.Set({self.}XmlChildSuff);
    end
    else begin
        raise "Invalid assignment: Suff expects PureWVal or nil";
    end
end;

function Lvl.ReadXmlChildLvlText(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildLvlText) or {self.}XmlChildLvlText.Removed) then
    begin
        {self.}XmlChildLvlText := new PureWVal(self, {self.}Prefix, "lvlText");
        container_.Set({self.}XmlChildLvlText);
    end
    return {self.}XmlChildLvlText and not {self.}XmlChildLvlText.Removed ? {self.}XmlChildLvlText : fallback_.XmlChildLvlText;
end;

function Lvl.WriteXmlChildLvlText(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildLvlText) then
            {self.}RemoveChild({self.}XmlChildLvlText);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildLvlText := v;
        container_.Set({self.}XmlChildLvlText);
    end
    else begin
        raise "Invalid assignment: LvlText expects PureWVal or nil";
    end
end;

function Lvl.ReadXmlChildLvlJc(): PureWVal;
begin
    if tslassigning and (ifnil({self.}XmlChildLvlJc) or {self.}XmlChildLvlJc.Removed) then
    begin
        {self.}XmlChildLvlJc := new PureWVal(self, {self.}Prefix, "lvlJc");
        container_.Set({self.}XmlChildLvlJc);
    end
    return {self.}XmlChildLvlJc and not {self.}XmlChildLvlJc.Removed ? {self.}XmlChildLvlJc : fallback_.XmlChildLvlJc;
end;

function Lvl.WriteXmlChildLvlJc(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildLvlJc) then
            {self.}RemoveChild({self.}XmlChildLvlJc);
    end
    else if v is class(PureWVal) then
    begin
        {self.}XmlChildLvlJc := v;
        container_.Set({self.}XmlChildLvlJc);
    end
    else begin
        raise "Invalid assignment: LvlJc expects PureWVal or nil";
    end
end;

function Lvl.ReadXmlChildPPr(): PPr;
begin
    if tslassigning and (ifnil({self.}XmlChildPPr) or {self.}XmlChildPPr.Removed) then
    begin
        {self.}XmlChildPPr := new PPr(self, {self.}Prefix, "pPr");
        container_.Set({self.}XmlChildPPr);
    end
    return {self.}XmlChildPPr and not {self.}XmlChildPPr.Removed ? {self.}XmlChildPPr : fallback_.XmlChildPPr;
end;

function Lvl.WriteXmlChildPPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildPPr) then
            {self.}RemoveChild({self.}XmlChildPPr);
    end
    else if v is class(PPr) then
    begin
        {self.}XmlChildPPr := v;
        container_.Set({self.}XmlChildPPr);
    end
    else begin
        raise "Invalid assignment: PPr expects PPr or nil";
    end
end;

function Lvl.ReadXmlChildRPr(): RPr;
begin
    if tslassigning and (ifnil({self.}XmlChildRPr) or {self.}XmlChildRPr.Removed) then
    begin
        {self.}XmlChildRPr := new RPr(self, {self.}Prefix, "rPr");
        container_.Set({self.}XmlChildRPr);
    end
    return {self.}XmlChildRPr and not {self.}XmlChildRPr.Removed ? {self.}XmlChildRPr : fallback_.XmlChildRPr;
end;

function Lvl.WriteXmlChildRPr(_p1: any; _p2: any);
begin
    v := realparamcount = 1 ? _p1 : _p2;
    if ifnil(v) then
    begin
        if ifObj({self.}XmlChildRPr) then
            {self.}RemoveChild({self.}XmlChildRPr);
    end
    else if v is class(RPr) then
    begin
        {self.}XmlChildRPr := v;
        container_.Set({self.}XmlChildRPr);
    end
    else begin
        raise "Invalid assignment: RPr expects RPr or nil";
    end
end;

end.