unit SharedML;
interface
uses DrawingML, DocxML;

type MathPr = 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: MathPr);override;
public

    // simple_type property
    property DispDef read ReadXmlChildDispDef;
    function ReadXmlChildDispDef(): OpenXmlSimpleType;

    // normal property
    property MathFont read ReadXmlChildMathFont;
    property BrkBin read ReadXmlChildBrkBin;
    property BrkBinSub read ReadXmlChildBrkBinSub;
    property SmallFrac read ReadXmlChildSmallFrac;
    property LMargin read ReadXmlChildLMargin;
    property RMargin read ReadXmlChildRMargin;
    property DefJc read ReadXmlChildDefJc;
    property WrapIndent read ReadXmlChildWrapIndent;
    property IntLim read ReadXmlChildIntLim;
    property NaryLim read ReadXmlChildNaryLim;
    function ReadXmlChildMathFont(): PureMVal;
    function ReadXmlChildBrkBin(): PureMVal;
    function ReadXmlChildBrkBinSub(): PureMVal;
    function ReadXmlChildSmallFrac(): PureMVal;
    function ReadXmlChildLMargin(): PureMVal;
    function ReadXmlChildRMargin(): PureMVal;
    function ReadXmlChildDefJc(): PureMVal;
    function ReadXmlChildWrapIndent(): PureMVal;
    function ReadXmlChildIntLim(): PureMVal;
    function ReadXmlChildNaryLim(): PureMVal;

public
    // Children
    XmlChildMathFont: PureMVal;
    XmlChildBrkBin: PureMVal;
    XmlChildBrkBinSub: PureMVal;
    XmlChildSmallFrac: PureMVal;
    XmlChildDispDef: OpenXmlSimpleType;
    XmlChildLMargin: PureMVal;
    XmlChildRMargin: PureMVal;
    XmlChildDefJc: PureMVal;
    XmlChildWrapIndent: PureMVal;
    XmlChildIntLim: PureMVal;
    XmlChildNaryLim: PureMVal;
end;

type OMathPara = 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: OMathPara);override;
public

    // normal property
    property OMathParaPr read ReadXmlChildOMathParaPr;
    property OMath read ReadXmlChildOMath;
    function ReadXmlChildOMathParaPr(): OMathParaPr;
    function ReadXmlChildOMath(): OMath;

public
    // Children
    XmlChildOMathParaPr: OMathParaPr;
    XmlChildOMath: OMath;
end;

type OMathParaPr = 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: OMathParaPr);override;
public

    // normal property
    property Jc read ReadXmlChildJc;
    function ReadXmlChildJc(): PureMVal;

public
    // Children
    XmlChildJc: PureMVal;
end;

type PureMVal = 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: PureMVal);override;
public
    // attributes property
    property Val read ReadXmlAttrVal write WriteXmlAttrVal;
    function ReadXmlAttrVal();
    function WriteXmlAttrVal(_value);

public
    // Attributes
    XmlAttrVal: OpenXmlAttribute;

end;

type OMath = 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: OMath);override;
public

    // multi property
    property Rs read ReadRs;
    property Ds read ReadDs;
    property Fs read ReadFs;
    property Rads read ReadRads;
    property SSubs read ReadSSubs;
    property Naries read ReadNaries;
    function ReadRs(_index);
    function ReadDs(_index);
    function ReadFs(_index);
    function ReadRads(_index);
    function ReadSSubs(_index);
    function ReadNaries(_index);
    function AddR(): R;
    function AddD(): D;
    function AddF(): F;
    function AddRad(): Rad;
    function AddSSub(): SSub;
    function AddNary(): Nary;
    function AppendR(): R;
    function AppendD(): D;
    function AppendF(): F;
    function AppendRad(): Rad;
    function AppendSSub(): SSub;
    function AppendNary(): Nary;

public
    // Children
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;
public

    // normal property
    property RPr read ReadXmlChildRPr;
    property ARPr read ReadXmlChildARPr;
    property WRPr read ReadXmlChildWRPr;
    property T read ReadXmlChildT;
    function ReadXmlChildRPr(_ns: string): RPr;
    function ReadXmlChildARPr(): RPr;
    function ReadXmlChildWRPr(): RPr;
    function ReadXmlChildT(): T;

public
    // Children
    XmlChildRPr: RPr;
    XmlChildARPr: RPr;
    XmlChildWRPr: RPr;
    XmlChildT: T;
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;
public

    // normal property
    property Sty read ReadXmlChildSty;
    function ReadXmlChildSty(): PureMVal;

public
    // Children
    XmlChildSty: PureMVal;
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;
public
    // attributes property
    property Space read ReadXmlAttrSpace write WriteXmlAttrSpace;
    function ReadXmlAttrSpace();
    function WriteXmlAttrSpace(_value);

public
    // Attributes
    XmlAttrSpace: OpenXmlAttribute;

end;

type D = 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: D);override;
public

    // normal property
    property DPr read ReadXmlChildDPr;
    property E read ReadXmlChildE;
    function ReadXmlChildDPr(): DPr;
    function ReadXmlChildE(): E;

public
    // Children
    XmlChildDPr: DPr;
    XmlChildE: E;
end;

type DPr = 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: DPr);override;
public

    // normal property
    property BegChr read ReadXmlChildBegChr;
    property EndChr read ReadXmlChildEndChr;
    property SepChr read ReadXmlChildSepChr;
    property Shp read ReadXmlChildShp;
    property Grow read ReadXmlChildGrow;
    property CtrlPr read ReadXmlChildCtrlPr;
    property RPr read ReadXmlChildRPr;
    function ReadXmlChildBegChr(): PureMVal;
    function ReadXmlChildEndChr(): PureMVal;
    function ReadXmlChildSepChr(): PureMVal;
    function ReadXmlChildShp(): PureMVal;
    function ReadXmlChildGrow(): PureMVal;
    function ReadXmlChildCtrlPr(): CtrlPr;
    function ReadXmlChildRPr(): RPr;

public
    // Children
    XmlChildBegChr: PureMVal;
    XmlChildEndChr: PureMVal;
    XmlChildSepChr: PureMVal;
    XmlChildShp: PureMVal;
    XmlChildGrow: PureMVal;
    XmlChildCtrlPr: CtrlPr;
    XmlChildRPr: RPr;
end;

type CtrlPr = 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: CtrlPr);override;
public

    // normal property
    property RPr read ReadXmlChildRPr;
    property Del read ReadXmlChildDel;
    function ReadXmlChildRPr(): RPr;
    function ReadXmlChildDel(): Del;

public
    // Children
    XmlChildRPr: RPr;
    XmlChildDel: Del;
end;

type E = 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: E);override;
public

    // normal property
    property F read ReadXmlChildF;
    property CtrlPr read ReadXmlChildCtrlPr;
    function ReadXmlChildF(): F;
    function ReadXmlChildCtrlPr(): CtrlPr;

    // multi property
    property Rs read ReadRs;
    property Ds read ReadDs;
    property SSups read ReadSSups;
    property SSubs read ReadSSubs;
    property Funcs read ReadFuncs;
    function ReadRs(_index);
    function ReadDs(_index);
    function ReadSSups(_index);
    function ReadSSubs(_index);
    function ReadFuncs(_index);
    function AddR(): R;
    function AddD(): D;
    function AddSSup(): SSup;
    function AddSSub(): SSub;
    function AddFunc(): Func;
    function AppendR(): R;
    function AppendD(): D;
    function AppendSSup(): SSup;
    function AppendSSub(): SSub;
    function AppendFunc(): Func;

public
    // Children
    XmlChildF: F;
    XmlChildCtrlPr: CtrlPr;
end;

type SSup = 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: SSup);override;
public

    // normal property
    property SSupPr read ReadXmlChildSSupPr;
    property E read ReadXmlChildE;
    property Sup read ReadXmlChildSup;
    function ReadXmlChildSSupPr(): SSupPr;
    function ReadXmlChildE(): E;
    function ReadXmlChildSup(): Sup;

public
    // Children
    XmlChildSSupPr: SSupPr;
    XmlChildE: E;
    XmlChildSup: Sup;
end;

type SSupPr = 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: SSupPr);override;
public

    // normal property
    property CtrlPr read ReadXmlChildCtrlPr;
    function ReadXmlChildCtrlPr(): CtrlPr;

public
    // Children
    XmlChildCtrlPr: CtrlPr;
end;

type Sup = 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: Sup);override;
public

    // normal property
    property CtrlPr read ReadXmlChildCtrlPr;
    function ReadXmlChildCtrlPr(): CtrlPr;

    // multi property
    property Rs read ReadRs;
    function ReadRs(_index);
    function AddR(): R;
    function AppendR(): R;

public
    // Children
    XmlChildCtrlPr: CtrlPr;
end;

type F = 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: F);override;
public

    // normal property
    property FPr read ReadXmlChildFPr;
    property Num read ReadXmlChildNum;
    property Den read ReadXmlChildDen;
    function ReadXmlChildFPr(): FPr;
    function ReadXmlChildNum(): Num;
    function ReadXmlChildDen(): Den;

public
    // Children
    XmlChildFPr: FPr;
    XmlChildNum: Num;
    XmlChildDen: Den;
end;

type FPr = 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: FPr);override;
public

    // normal property
    property Type read ReadXmlChildType;
    property CtrlPr read ReadXmlChildCtrlPr;
    function ReadXmlChildType(): PureMVal;
    function ReadXmlChildCtrlPr(): CtrlPr;

public
    // Children
    XmlChildType: PureMVal;
    XmlChildCtrlPr: CtrlPr;
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;
public

    // normal property
    property Rad read ReadXmlChildRad;
    property CtrlPr read ReadXmlChildCtrlPr;
    function ReadXmlChildRad(): Rad;
    function ReadXmlChildCtrlPr(): CtrlPr;

    // multi property
    property Rs read ReadRs;
    function ReadRs(_index);
    function AddR(): R;
    function AppendR(): R;

public
    // Children
    XmlChildRad: Rad;
    XmlChildCtrlPr: CtrlPr;
end;

type Rad = 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: Rad);override;
public

    // normal property
    property RadPr read ReadXmlChildRadPr;
    property Deg read ReadXmlChildDeg;
    property E read ReadXmlChildE;
    function ReadXmlChildRadPr(): RadPr;
    function ReadXmlChildDeg(): Deg;
    function ReadXmlChildE(): E;

public
    // Children
    XmlChildRadPr: RadPr;
    XmlChildDeg: Deg;
    XmlChildE: E;
end;

type RadPr = 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: RadPr);override;
public

    // normal property
    property DegHide read ReadXmlChildDegHide;
    property CtrlPr read ReadXmlChildCtrlPr;
    function ReadXmlChildDegHide(): PureMVal;
    function ReadXmlChildCtrlPr(): CtrlPr;

public
    // Children
    XmlChildDegHide: PureMVal;
    XmlChildCtrlPr: CtrlPr;
end;

type Deg = 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: Deg);override;
public

    // normal property
    property CtrlPr read ReadXmlChildCtrlPr;
    function ReadXmlChildCtrlPr(): CtrlPr;

public
    // Children
    XmlChildCtrlPr: CtrlPr;
end;

type Den = 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: Den);override;
public

    // multi property
    property Rs read ReadRs;
    function ReadRs(_index);
    function AddR(): R;
    function AppendR(): R;

public
    // Children
end;

type SSub = 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: SSub);override;
public

    // normal property
    property SSubPr read ReadXmlChildSSubPr;
    property E read ReadXmlChildE;
    property Sub read ReadXmlChildSub;
    function ReadXmlChildSSubPr(): SSubPr;
    function ReadXmlChildE(): E;
    function ReadXmlChildSub(): Sub;

public
    // Children
    XmlChildSSubPr: SSubPr;
    XmlChildE: E;
    XmlChildSub: Sub;
end;

type SSubPr = 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: SSubPr);override;
public

    // normal property
    property CtrlPr read ReadXmlChildCtrlPr;
    function ReadXmlChildCtrlPr(): CtrlPr;

public
    // Children
    XmlChildCtrlPr: CtrlPr;
end;

type Sub = 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: Sub);override;
public

    // normal property
    property CtrlPr read ReadXmlChildCtrlPr;
    function ReadXmlChildCtrlPr(): CtrlPr;

    // multi property
    property Rs read ReadRs;
    function ReadRs(_index);
    function AddR(): R;
    function AppendR(): R;

public
    // Children
    XmlChildCtrlPr: CtrlPr;
end;

type Nary = 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: Nary);override;
public

    // normal property
    property NaryPr read ReadXmlChildNaryPr;
    property Sub read ReadXmlChildSub;
    property Sup read ReadXmlChildSup;
    property E read ReadXmlChildE;
    function ReadXmlChildNaryPr(): NaryPr;
    function ReadXmlChildSub(): Sub;
    function ReadXmlChildSup(): Sup;
    function ReadXmlChildE(): E;

public
    // Children
    XmlChildNaryPr: NaryPr;
    XmlChildSub: Sub;
    XmlChildSup: Sup;
    XmlChildE: E;
end;

type NaryPr = 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: NaryPr);override;
public

    // normal property
    property Chr read ReadXmlChildChr;
    property Grow read ReadXmlChildGrow;
    property SubHide read ReadXmlChildSubHide;
    property SupHide read ReadXmlChildSupHide;
    property LimLoc read ReadXmlChildLimLoc;
    property CtrlPr read ReadXmlChildCtrlPr;
    function ReadXmlChildChr(): PureMVal;
    function ReadXmlChildGrow(): PureMVal;
    function ReadXmlChildSubHide(): PureMVal;
    function ReadXmlChildSupHide(): PureMVal;
    function ReadXmlChildLimLoc(): PureMVal;
    function ReadXmlChildCtrlPr(): CtrlPr;

public
    // Children
    XmlChildChr: PureMVal;
    XmlChildGrow: PureMVal;
    XmlChildSubHide: PureMVal;
    XmlChildSupHide: PureMVal;
    XmlChildLimLoc: PureMVal;
    XmlChildCtrlPr: CtrlPr;
end;

type Func = 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: Func);override;
public

    // normal property
    property FuncPr read ReadXmlChildFuncPr;
    property FName read ReadXmlChildFName;
    property E read ReadXmlChildE;
    function ReadXmlChildFuncPr(): FuncPr;
    function ReadXmlChildFName(): FName;
    function ReadXmlChildE(): E;

public
    // Children
    XmlChildFuncPr: FuncPr;
    XmlChildFName: FName;
    XmlChildE: E;
end;

type FName = 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: FName);override;
public

    // multi property
    property Rs read ReadRs;
    function ReadRs(_index);
    function AddR(): R;
    function AppendR(): R;

public
    // Children
end;

type FuncPr = 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: FuncPr);override;
public

    // normal property
    property CtrlPr read ReadXmlChildCtrlPr;
    function ReadXmlChildCtrlPr(): CtrlPr;

public
    // Children
    XmlChildCtrlPr: CtrlPr;
end;

type CoreProperties = 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: CoreProperties);override;
public

    // pcdata property
    property Title read ReadXmlChildTitle;
    property Subject read ReadXmlChildSubject;
    property Creator read ReadXmlChildCreator;
    property Keywords read ReadXmlChildKeywords;
    property Description read ReadXmlChildDescription;
    property LastModifiedBy read ReadXmlChildLastModifiedBy;
    property Revision read ReadXmlChildRevision;
    property LastPrinted read ReadXmlChildLastPrinted;
    property Created read ReadXmlChildCreated;
    property Modified read ReadXmlChildModified;
    function ReadXmlChildTitle();
    function ReadXmlChildSubject();
    function ReadXmlChildCreator();
    function ReadXmlChildKeywords();
    function ReadXmlChildDescription();
    function ReadXmlChildLastModifiedBy();
    function ReadXmlChildRevision();
    function ReadXmlChildLastPrinted();
    function ReadXmlChildCreated();
    function ReadXmlChildModified();

public
    // Children
    XmlChildTitle: OpenXmlTextElement;
    XmlChildSubject: OpenXmlTextElement;
    XmlChildCreator: OpenXmlTextElement;
    XmlChildKeywords: OpenXmlTextElement;
    XmlChildDescription: OpenXmlTextElement;
    XmlChildLastModifiedBy: OpenXmlTextElement;
    XmlChildRevision: OpenXmlTextElement;
    XmlChildLastPrinted: OpenXmlTextElement;
    XmlChildCreated: Created;
    XmlChildModified: Modified;
end;

type Created = 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: Created);override;
public
    // attributes property
    property Type read ReadXmlAttrType write WriteXmlAttrType;
    function ReadXmlAttrType();
    function WriteXmlAttrType(_value);

public
    // Attributes
    XmlAttrType: OpenXmlAttribute;

end;

type Modified = 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: Modified);override;
public
    // attributes property
    property Type read ReadXmlAttrType write WriteXmlAttrType;
    function ReadXmlAttrType();
    function WriteXmlAttrType(_value);

public
    // Attributes
    XmlAttrType: OpenXmlAttribute;

end;

type Relationships = 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: Relationships);override;
public

    // multi property
    property Relationships read ReadRelationships;
    function ReadRelationships(_index);
    function AddRelationship(): Relationship;
    function AppendRelationship(): Relationship;

public
    // Children
end;

type Relationship = 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: Relationship);override;
public
    // attributes property
    property Id read ReadXmlAttrId write WriteXmlAttrId;
    property Type read ReadXmlAttrType write WriteXmlAttrType;
    property Target read ReadXmlAttrTarget write WriteXmlAttrTarget;
    function ReadXmlAttrId();
    function WriteXmlAttrId(_value);
    function ReadXmlAttrType();
    function WriteXmlAttrType(_value);
    function ReadXmlAttrTarget();
    function WriteXmlAttrTarget(_value);

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

end;

type Types = 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: Types);override;
public

    // multi property
    property Defaults read ReadDefaults;
    property Overrides read ReadOverrides;
    function ReadDefaults(_index);
    function ReadOverrides(_index);
    function AddDefault(): Default;
    function AddOverride(): _Override;
    function AppendDefault(): Default;
    function AppendOverride(): _Override;

public
    // Children
end;

type Default = 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: Default);override;
public
    // attributes property
    property Extension read ReadXmlAttrExtension write WriteXmlAttrExtension;
    property ContentType read ReadXmlAttrContentType write WriteXmlAttrContentType;
    function ReadXmlAttrExtension();
    function WriteXmlAttrExtension(_value);
    function ReadXmlAttrContentType();
    function WriteXmlAttrContentType(_value);

public
    // Attributes
    XmlAttrExtension: OpenXmlAttribute;
    XmlAttrContentType: OpenXmlAttribute;

end;

type _Override = 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: _Override);override;
public
    // attributes property
    property PartName read ReadXmlAttrPartName write WriteXmlAttrPartName;
    property ContentType read ReadXmlAttrContentType write WriteXmlAttrContentType;
    function ReadXmlAttrPartName();
    function WriteXmlAttrPartName(_value);
    function ReadXmlAttrContentType();
    function WriteXmlAttrContentType(_value);

public
    // Attributes
    XmlAttrPartName: OpenXmlAttribute;
    XmlAttrContentType: OpenXmlAttribute;

end;

implementation

function MathPr.Create();overload;
begin
    {self.}Create(nil, "m", "mathPr");
end;

function MathPr.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function MathPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "mathFont": array(0, makeweakref(thisFunction(ReadXmlChildMathFont))),
        pre + "brkBin": array(1, makeweakref(thisFunction(ReadXmlChildBrkBin))),
        pre + "brkBinSub": array(2, makeweakref(thisFunction(ReadXmlChildBrkBinSub))),
        pre + "smallFrac": array(3, makeweakref(thisFunction(ReadXmlChildSmallFrac))),
        pre + "dispDef": array(4, makeweakref(thisFunction(ReadXmlChildDispDef))),
        pre + "lMargin": array(5, makeweakref(thisFunction(ReadXmlChildLMargin))),
        pre + "rMargin": array(6, makeweakref(thisFunction(ReadXmlChildRMargin))),
        pre + "defJc": array(7, makeweakref(thisFunction(ReadXmlChildDefJc))),
        pre + "wrapIndent": array(8, makeweakref(thisFunction(ReadXmlChildWrapIndent))),
        pre + "intLim": array(9, makeweakref(thisFunction(ReadXmlChildIntLim))),
        pre + "naryLim": array(10, makeweakref(thisFunction(ReadXmlChildNaryLim))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function MathPr.Copy(_obj: MathPr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildMathFont) then
        {self.}MathFont.Copy(_obj.XmlChildMathFont);
    if not ifnil(_obj.XmlChildBrkBin) then
        {self.}BrkBin.Copy(_obj.XmlChildBrkBin);
    if not ifnil(_obj.XmlChildBrkBinSub) then
        {self.}BrkBinSub.Copy(_obj.XmlChildBrkBinSub);
    if not ifnil(_obj.XmlChildSmallFrac) then
        {self.}SmallFrac.Copy(_obj.XmlChildSmallFrac);
    if not ifnil(_obj.XmlChildDispDef) then
        ifnil({self.}XmlChildDispDef) ? {self.}DispDef.Copy(_obj.XmlChildDispDef) : {self.}XmlChildDispDef.Copy(_obj.XmlChildDispDef);
    if not ifnil(_obj.XmlChildLMargin) then
        {self.}LMargin.Copy(_obj.XmlChildLMargin);
    if not ifnil(_obj.XmlChildRMargin) then
        {self.}RMargin.Copy(_obj.XmlChildRMargin);
    if not ifnil(_obj.XmlChildDefJc) then
        {self.}DefJc.Copy(_obj.XmlChildDefJc);
    if not ifnil(_obj.XmlChildWrapIndent) then
        {self.}WrapIndent.Copy(_obj.XmlChildWrapIndent);
    if not ifnil(_obj.XmlChildIntLim) then
        {self.}IntLim.Copy(_obj.XmlChildIntLim);
    if not ifnil(_obj.XmlChildNaryLim) then
        {self.}NaryLim.Copy(_obj.XmlChildNaryLim);
    tslassigning := tslassigning_backup;
end;

function MathPr.ReadXmlChildDispDef();
begin
    if tslassigning and (ifnil({self.}XmlChildDispDef) or {self.}XmlChildDispDef.Removed) then
    begin
        {self.}XmlChildDispDef := new OpenXmlSimpleType(self, {self.}Prefix, "dispDef");
        container_.Set({self.}XmlChildDispDef);
    end
    return {self.}XmlChildDispDef;
end;

function MathPr.ReadXmlChildMathFont(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildMathFont) or {self.}XmlChildMathFont.Removed) then
    begin
        {self.}XmlChildMathFont := new PureMVal(self, {self.}Prefix, "mathFont");
        container_.Set({self.}XmlChildMathFont);
    end
    return {self.}XmlChildMathFont;
end;

function MathPr.ReadXmlChildBrkBin(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildBrkBin) or {self.}XmlChildBrkBin.Removed) then
    begin
        {self.}XmlChildBrkBin := new PureMVal(self, {self.}Prefix, "brkBin");
        container_.Set({self.}XmlChildBrkBin);
    end
    return {self.}XmlChildBrkBin;
end;

function MathPr.ReadXmlChildBrkBinSub(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildBrkBinSub) or {self.}XmlChildBrkBinSub.Removed) then
    begin
        {self.}XmlChildBrkBinSub := new PureMVal(self, {self.}Prefix, "brkBinSub");
        container_.Set({self.}XmlChildBrkBinSub);
    end
    return {self.}XmlChildBrkBinSub;
end;

function MathPr.ReadXmlChildSmallFrac(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildSmallFrac) or {self.}XmlChildSmallFrac.Removed) then
    begin
        {self.}XmlChildSmallFrac := new PureMVal(self, {self.}Prefix, "smallFrac");
        container_.Set({self.}XmlChildSmallFrac);
    end
    return {self.}XmlChildSmallFrac;
end;

function MathPr.ReadXmlChildLMargin(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildLMargin) or {self.}XmlChildLMargin.Removed) then
    begin
        {self.}XmlChildLMargin := new PureMVal(self, {self.}Prefix, "lMargin");
        container_.Set({self.}XmlChildLMargin);
    end
    return {self.}XmlChildLMargin;
end;

function MathPr.ReadXmlChildRMargin(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildRMargin) or {self.}XmlChildRMargin.Removed) then
    begin
        {self.}XmlChildRMargin := new PureMVal(self, {self.}Prefix, "rMargin");
        container_.Set({self.}XmlChildRMargin);
    end
    return {self.}XmlChildRMargin;
end;

function MathPr.ReadXmlChildDefJc(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildDefJc) or {self.}XmlChildDefJc.Removed) then
    begin
        {self.}XmlChildDefJc := new PureMVal(self, {self.}Prefix, "defJc");
        container_.Set({self.}XmlChildDefJc);
    end
    return {self.}XmlChildDefJc;
end;

function MathPr.ReadXmlChildWrapIndent(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildWrapIndent) or {self.}XmlChildWrapIndent.Removed) then
    begin
        {self.}XmlChildWrapIndent := new PureMVal(self, {self.}Prefix, "wrapIndent");
        container_.Set({self.}XmlChildWrapIndent);
    end
    return {self.}XmlChildWrapIndent;
end;

function MathPr.ReadXmlChildIntLim(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildIntLim) or {self.}XmlChildIntLim.Removed) then
    begin
        {self.}XmlChildIntLim := new PureMVal(self, {self.}Prefix, "intLim");
        container_.Set({self.}XmlChildIntLim);
    end
    return {self.}XmlChildIntLim;
end;

function MathPr.ReadXmlChildNaryLim(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildNaryLim) or {self.}XmlChildNaryLim.Removed) then
    begin
        {self.}XmlChildNaryLim := new PureMVal(self, {self.}Prefix, "naryLim");
        container_.Set({self.}XmlChildNaryLim);
    end
    return {self.}XmlChildNaryLim;
end;

function OMathPara.Create();overload;
begin
    {self.}Create(nil, "m", "oMathPara");
end;

function OMathPara.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function OMathPara.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "oMathParaPr": array(0, makeweakref(thisFunction(ReadXmlChildOMathParaPr))),
        pre + "oMath": array(1, makeweakref(thisFunction(ReadXmlChildOMath))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function OMathPara.Copy(_obj: OMathPara);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildOMathParaPr) then
        {self.}OMathParaPr.Copy(_obj.XmlChildOMathParaPr);
    if not ifnil(_obj.XmlChildOMath) then
        {self.}OMath.Copy(_obj.XmlChildOMath);
    tslassigning := tslassigning_backup;
end;

function OMathPara.ReadXmlChildOMathParaPr(): OMathParaPr;
begin
    if tslassigning and (ifnil({self.}XmlChildOMathParaPr) or {self.}XmlChildOMathParaPr.Removed) then
    begin
        {self.}XmlChildOMathParaPr := new OMathParaPr(self, {self.}Prefix, "oMathParaPr");
        container_.Set({self.}XmlChildOMathParaPr);
    end
    return {self.}XmlChildOMathParaPr;
end;

function OMathPara.ReadXmlChildOMath(): OMath;
begin
    if tslassigning and (ifnil({self.}XmlChildOMath) or {self.}XmlChildOMath.Removed) then
    begin
        {self.}XmlChildOMath := new OMath(self, {self.}Prefix, "oMath");
        container_.Set({self.}XmlChildOMath);
    end
    return {self.}XmlChildOMath;
end;

function OMathParaPr.Create();overload;
begin
    {self.}Create(nil, "m", "oMathParaPr");
end;

function OMathParaPr.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

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

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

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

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

function PureMVal.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function PureMVal.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 PureMVal.Copy(_obj: PureMVal);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 PureMVal.ReadXmlAttrVal();
begin
    return {self.}XmlAttrVal.Value;
end;

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

function OMath.Create();overload;
begin
    {self.}Create(nil, "m", "oMath");
end;

function OMath.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function OMath.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "r": array(0, makeweakref(thisFunction(AppendR))),
        pre + "d": array(1, makeweakref(thisFunction(AppendD))),
        pre + "f": array(2, makeweakref(thisFunction(AppendF))),
        pre + "rad": array(3, makeweakref(thisFunction(AppendRad))),
        pre + "sSub": array(4, makeweakref(thisFunction(AppendSSub))),
        pre + "nary": array(5, makeweakref(thisFunction(AppendNary))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

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

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

function OMath.ReadDs(_index);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "d", ind);
end;

function OMath.ReadFs(_index);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "f", ind);
end;

function OMath.ReadRads(_index);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "rad", ind);
end;

function OMath.ReadSSubs(_index);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "sSub", ind);
end;

function OMath.ReadNaries(_index);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "nary", ind);
end;

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

function OMath.AddD(): D;
begin
    obj := new D(self, {self.}Prefix, "d");
    container_.Insert(obj);
    return obj;
end;

function OMath.AddF(): F;
begin
    obj := new F(self, {self.}Prefix, "f");
    container_.Insert(obj);
    return obj;
end;

function OMath.AddRad(): Rad;
begin
    obj := new Rad(self, {self.}Prefix, "rad");
    container_.Insert(obj);
    return obj;
end;

function OMath.AddSSub(): SSub;
begin
    obj := new SSub(self, {self.}Prefix, "sSub");
    container_.Insert(obj);
    return obj;
end;

function OMath.AddNary(): Nary;
begin
    obj := new Nary(self, {self.}Prefix, "nary");
    container_.Insert(obj);
    return obj;
end;

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

function OMath.AppendD(): D;
begin
    obj := new D(self, {self.}Prefix, "d");
    container_.Append(obj);
    return obj;
end;

function OMath.AppendF(): F;
begin
    obj := new F(self, {self.}Prefix, "f");
    container_.Append(obj);
    return obj;
end;

function OMath.AppendRad(): Rad;
begin
    obj := new Rad(self, {self.}Prefix, "rad");
    container_.Append(obj);
    return obj;
end;

function OMath.AppendSSub(): SSub;
begin
    obj := new SSub(self, {self.}Prefix, "sSub");
    container_.Append(obj);
    return obj;
end;

function OMath.AppendNary(): Nary;
begin
    obj := new Nary(self, {self.}Prefix, "nary");
    container_.Append(obj);
    return obj;
end;

function R.Create();overload;
begin
    {self.}Create(nil, "m", "r");
end;

function R.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function R.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "rPr": array(0, makeweakref(thisFunction(ReadXmlChildRPr))),
        "a:rPr": array(1, makeweakref(thisFunction(ReadXmlChildARPr))),
        "w:rPr": array(2, makeweakref(thisFunction(ReadXmlChildWRPr))),
        pre + "t": array(3, makeweakref(thisFunction(ReadXmlChildT))),
    );
    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.XmlChildRPr) then
        {self.}RPr.Copy(_obj.XmlChildRPr);
    if not ifnil(_obj.XmlChildARPr) then
        {self.}ARPr.Copy(_obj.XmlChildARPr);
    if not ifnil(_obj.XmlChildWRPr) then
        {self.}WRPr.Copy(_obj.XmlChildWRPr);
    if not ifnil(_obj.XmlChildT) then
        {self.}T.Copy(_obj.XmlChildT);
    tslassigning := tslassigning_backup;
end;

function R.ReadXmlChildRPr(_ns: string): RPr;
begin
    if _ns = "a" then
        return ReadXmlChildARPr();
    else if _ns = "w" then
        return ReadXmlChildWRPr();
    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;
end;

function R.ReadXmlChildARPr(): RPr;
begin
    if tslassigning and (ifnil({self.}XmlChildARPr) or {self.}XmlChildARPr.Removed) then
    begin
        {self.}XmlChildARPr := new DrawingML.RPr(self, "a", "rPr");
        container_.Set({self.}XmlChildARPr);
    end
    return {self.}XmlChildARPr;
end;

function R.ReadXmlChildWRPr(): RPr;
begin
    if tslassigning and (ifnil({self.}XmlChildWRPr) or {self.}XmlChildWRPr.Removed) then
    begin
        {self.}XmlChildWRPr := new DocxML.RPr(self, "w", "rPr");
        container_.Set({self.}XmlChildWRPr);
    end
    return {self.}XmlChildWRPr;
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;
end;

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

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

function RPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    class(OpenXmlCompositeElement).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 + "sty": array(0, makeweakref(thisFunction(ReadXmlChildSty))),
    );
    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.XmlChildSty) then
        {self.}Sty.Copy(_obj.XmlChildSty);
    tslassigning := tslassigning_backup;
end;

function RPr.ReadXmlChildSty(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildSty) or {self.}XmlChildSty.Removed) then
    begin
        {self.}XmlChildSty := new PureMVal(self, {self.}Prefix, "sty");
        container_.Set({self.}XmlChildSty);
    end
    return {self.}XmlChildSty;
end;

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

function T.Create(_node: XmlNode);overload;
begin
    class(OpenXmlTextElement).Create(_node: XmlNode);
end;

function T.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
    class(OpenXmlTextElement).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.ReadXmlAttrSpace();
begin
    return {self.}XmlAttrSpace.Value;
end;

function T.WriteXmlAttrSpace(_value);
begin
    if ifnil({self.}XmlAttrSpace) then
    begin
        {self.}XmlAttrSpace := new OpenXmlAttribute("xml", "space", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrSpace;
    end
    {self.}XmlAttrSpace.Value := _value;
end;

function D.Create();overload;
begin
    {self.}Create(nil, "m", "d");
end;

function D.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function D.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "dPr": array(0, makeweakref(thisFunction(ReadXmlChildDPr))),
        pre + "e": array(1, makeweakref(thisFunction(ReadXmlChildE))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function D.Copy(_obj: D);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildDPr) then
        {self.}DPr.Copy(_obj.XmlChildDPr);
    if not ifnil(_obj.XmlChildE) then
        {self.}E.Copy(_obj.XmlChildE);
    tslassigning := tslassigning_backup;
end;

function D.ReadXmlChildDPr(): DPr;
begin
    if tslassigning and (ifnil({self.}XmlChildDPr) or {self.}XmlChildDPr.Removed) then
    begin
        {self.}XmlChildDPr := new DPr(self, {self.}Prefix, "dPr");
        container_.Set({self.}XmlChildDPr);
    end
    return {self.}XmlChildDPr;
end;

function D.ReadXmlChildE(): E;
begin
    if tslassigning and (ifnil({self.}XmlChildE) or {self.}XmlChildE.Removed) then
    begin
        {self.}XmlChildE := new E(self, {self.}Prefix, "e");
        container_.Set({self.}XmlChildE);
    end
    return {self.}XmlChildE;
end;

function DPr.Create();overload;
begin
    {self.}Create(nil, "m", "dPr");
end;

function DPr.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function DPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "begChr": array(0, makeweakref(thisFunction(ReadXmlChildBegChr))),
        pre + "endChr": array(1, makeweakref(thisFunction(ReadXmlChildEndChr))),
        pre + "sepChr": array(2, makeweakref(thisFunction(ReadXmlChildSepChr))),
        pre + "shp": array(3, makeweakref(thisFunction(ReadXmlChildShp))),
        pre + "grow": array(4, makeweakref(thisFunction(ReadXmlChildGrow))),
        pre + "ctrlPr": array(5, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
        "w:rPr": array(6, makeweakref(thisFunction(ReadXmlChildRPr))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function DPr.Copy(_obj: DPr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildBegChr) then
        {self.}BegChr.Copy(_obj.XmlChildBegChr);
    if not ifnil(_obj.XmlChildEndChr) then
        {self.}EndChr.Copy(_obj.XmlChildEndChr);
    if not ifnil(_obj.XmlChildSepChr) then
        {self.}SepChr.Copy(_obj.XmlChildSepChr);
    if not ifnil(_obj.XmlChildShp) then
        {self.}Shp.Copy(_obj.XmlChildShp);
    if not ifnil(_obj.XmlChildGrow) then
        {self.}Grow.Copy(_obj.XmlChildGrow);
    if not ifnil(_obj.XmlChildCtrlPr) then
        {self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
    if not ifnil(_obj.XmlChildRPr) then
        {self.}RPr.Copy(_obj.XmlChildRPr);
    tslassigning := tslassigning_backup;
end;

function DPr.ReadXmlChildBegChr(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildBegChr) or {self.}XmlChildBegChr.Removed) then
    begin
        {self.}XmlChildBegChr := new PureMVal(self, {self.}Prefix, "begChr");
        container_.Set({self.}XmlChildBegChr);
    end
    return {self.}XmlChildBegChr;
end;

function DPr.ReadXmlChildEndChr(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildEndChr) or {self.}XmlChildEndChr.Removed) then
    begin
        {self.}XmlChildEndChr := new PureMVal(self, {self.}Prefix, "endChr");
        container_.Set({self.}XmlChildEndChr);
    end
    return {self.}XmlChildEndChr;
end;

function DPr.ReadXmlChildSepChr(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildSepChr) or {self.}XmlChildSepChr.Removed) then
    begin
        {self.}XmlChildSepChr := new PureMVal(self, {self.}Prefix, "sepChr");
        container_.Set({self.}XmlChildSepChr);
    end
    return {self.}XmlChildSepChr;
end;

function DPr.ReadXmlChildShp(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildShp) or {self.}XmlChildShp.Removed) then
    begin
        {self.}XmlChildShp := new PureMVal(self, {self.}Prefix, "shp");
        container_.Set({self.}XmlChildShp);
    end
    return {self.}XmlChildShp;
end;

function DPr.ReadXmlChildGrow(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildGrow) or {self.}XmlChildGrow.Removed) then
    begin
        {self.}XmlChildGrow := new PureMVal(self, {self.}Prefix, "grow");
        container_.Set({self.}XmlChildGrow);
    end
    return {self.}XmlChildGrow;
end;

function DPr.ReadXmlChildCtrlPr(): CtrlPr;
begin
    if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
    begin
        {self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
        container_.Set({self.}XmlChildCtrlPr);
    end
    return {self.}XmlChildCtrlPr;
end;

function DPr.ReadXmlChildRPr(): RPr;
begin
    if tslassigning and (ifnil({self.}XmlChildRPr) or {self.}XmlChildRPr.Removed) then
    begin
        {self.}XmlChildRPr := new DocxML.RPr(self, "w", "rPr");
        container_.Set({self.}XmlChildRPr);
    end
    return {self.}XmlChildRPr;
end;

function CtrlPr.Create();overload;
begin
    {self.}Create(nil, "m", "ctrlPr");
end;

function CtrlPr.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function CtrlPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "rPr": array(0, makeweakref(thisFunction(ReadXmlChildRPr))),
        pre + "del": array(1, makeweakref(thisFunction(ReadXmlChildDel))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function CtrlPr.Copy(_obj: CtrlPr);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.XmlChildDel) then
        {self.}Del.Copy(_obj.XmlChildDel);
    tslassigning := tslassigning_backup;
end;

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

function CtrlPr.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;
end;

function E.Create();overload;
begin
    {self.}Create(nil, "m", "e");
end;

function E.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function E.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "r": array(0, makeweakref(thisFunction(AppendR))),
        pre + "d": array(1, makeweakref(thisFunction(AppendD))),
        pre + "sSup": array(2, makeweakref(thisFunction(AppendSSup))),
        pre + "sSub": array(3, makeweakref(thisFunction(AppendSSub))),
        pre + "func": array(4, makeweakref(thisFunction(AppendFunc))),
        pre + "f": array(5, makeweakref(thisFunction(ReadXmlChildF))),
        pre + "ctrlPr": array(6, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function E.Copy(_obj: E);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildF) then
        {self.}F.Copy(_obj.XmlChildF);
    if not ifnil(_obj.XmlChildCtrlPr) then
        {self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
    tslassigning := tslassigning_backup;
end;

function E.ReadXmlChildF(): F;
begin
    if tslassigning and (ifnil({self.}XmlChildF) or {self.}XmlChildF.Removed) then
    begin
        {self.}XmlChildF := new F(self, {self.}Prefix, "f");
        container_.Set({self.}XmlChildF);
    end
    return {self.}XmlChildF;
end;

function E.ReadXmlChildCtrlPr(): CtrlPr;
begin
    if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
    begin
        {self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
        container_.Set({self.}XmlChildCtrlPr);
    end
    return {self.}XmlChildCtrlPr;
end;

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

function E.ReadDs(_index);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "d", ind);
end;

function E.ReadSSups(_index);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "sSup", ind);
end;

function E.ReadSSubs(_index);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "sSub", ind);
end;

function E.ReadFuncs(_index);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "func", ind);
end;

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

function E.AddD(): D;
begin
    obj := new D(self, {self.}Prefix, "d");
    container_.Insert(obj);
    return obj;
end;

function E.AddSSup(): SSup;
begin
    obj := new SSup(self, {self.}Prefix, "sSup");
    container_.Insert(obj);
    return obj;
end;

function E.AddSSub(): SSub;
begin
    obj := new SSub(self, {self.}Prefix, "sSub");
    container_.Insert(obj);
    return obj;
end;

function E.AddFunc(): Func;
begin
    obj := new Func(self, {self.}Prefix, "func");
    container_.Insert(obj);
    return obj;
end;

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

function E.AppendD(): D;
begin
    obj := new D(self, {self.}Prefix, "d");
    container_.Append(obj);
    return obj;
end;

function E.AppendSSup(): SSup;
begin
    obj := new SSup(self, {self.}Prefix, "sSup");
    container_.Append(obj);
    return obj;
end;

function E.AppendSSub(): SSub;
begin
    obj := new SSub(self, {self.}Prefix, "sSub");
    container_.Append(obj);
    return obj;
end;

function E.AppendFunc(): Func;
begin
    obj := new Func(self, {self.}Prefix, "func");
    container_.Append(obj);
    return obj;
end;

function SSup.Create();overload;
begin
    {self.}Create(nil, "m", "sSup");
end;

function SSup.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function SSup.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "sSupPr": array(0, makeweakref(thisFunction(ReadXmlChildSSupPr))),
        pre + "e": array(1, makeweakref(thisFunction(ReadXmlChildE))),
        pre + "sup": array(2, makeweakref(thisFunction(ReadXmlChildSup))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function SSup.Copy(_obj: SSup);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildSSupPr) then
        {self.}SSupPr.Copy(_obj.XmlChildSSupPr);
    if not ifnil(_obj.XmlChildE) then
        {self.}E.Copy(_obj.XmlChildE);
    if not ifnil(_obj.XmlChildSup) then
        {self.}Sup.Copy(_obj.XmlChildSup);
    tslassigning := tslassigning_backup;
end;

function SSup.ReadXmlChildSSupPr(): SSupPr;
begin
    if tslassigning and (ifnil({self.}XmlChildSSupPr) or {self.}XmlChildSSupPr.Removed) then
    begin
        {self.}XmlChildSSupPr := new SSupPr(self, {self.}Prefix, "sSupPr");
        container_.Set({self.}XmlChildSSupPr);
    end
    return {self.}XmlChildSSupPr;
end;

function SSup.ReadXmlChildE(): E;
begin
    if tslassigning and (ifnil({self.}XmlChildE) or {self.}XmlChildE.Removed) then
    begin
        {self.}XmlChildE := new E(self, {self.}Prefix, "e");
        container_.Set({self.}XmlChildE);
    end
    return {self.}XmlChildE;
end;

function SSup.ReadXmlChildSup(): Sup;
begin
    if tslassigning and (ifnil({self.}XmlChildSup) or {self.}XmlChildSup.Removed) then
    begin
        {self.}XmlChildSup := new Sup(self, {self.}Prefix, "sup");
        container_.Set({self.}XmlChildSup);
    end
    return {self.}XmlChildSup;
end;

function SSupPr.Create();overload;
begin
    {self.}Create(nil, "m", "sSupPr");
end;

function SSupPr.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

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

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

function SSupPr.ReadXmlChildCtrlPr(): CtrlPr;
begin
    if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
    begin
        {self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
        container_.Set({self.}XmlChildCtrlPr);
    end
    return {self.}XmlChildCtrlPr;
end;

function Sup.Create();overload;
begin
    {self.}Create(nil, "m", "sup");
end;

function Sup.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function Sup.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "r": array(0, makeweakref(thisFunction(AppendR))),
        pre + "ctrlPr": array(1, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

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

function Sup.ReadXmlChildCtrlPr(): CtrlPr;
begin
    if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
    begin
        {self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
        container_.Set({self.}XmlChildCtrlPr);
    end
    return {self.}XmlChildCtrlPr;
end;

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

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

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

function F.Create();overload;
begin
    {self.}Create(nil, "m", "f");
end;

function F.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function F.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "fPr": array(0, makeweakref(thisFunction(ReadXmlChildFPr))),
        pre + "num": array(1, makeweakref(thisFunction(ReadXmlChildNum))),
        pre + "den": array(2, makeweakref(thisFunction(ReadXmlChildDen))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function F.Copy(_obj: F);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildFPr) then
        {self.}FPr.Copy(_obj.XmlChildFPr);
    if not ifnil(_obj.XmlChildNum) then
        {self.}Num.Copy(_obj.XmlChildNum);
    if not ifnil(_obj.XmlChildDen) then
        {self.}Den.Copy(_obj.XmlChildDen);
    tslassigning := tslassigning_backup;
end;

function F.ReadXmlChildFPr(): FPr;
begin
    if tslassigning and (ifnil({self.}XmlChildFPr) or {self.}XmlChildFPr.Removed) then
    begin
        {self.}XmlChildFPr := new FPr(self, {self.}Prefix, "fPr");
        container_.Set({self.}XmlChildFPr);
    end
    return {self.}XmlChildFPr;
end;

function F.ReadXmlChildNum(): Num;
begin
    if tslassigning and (ifnil({self.}XmlChildNum) or {self.}XmlChildNum.Removed) then
    begin
        {self.}XmlChildNum := new Num(self, {self.}Prefix, "num");
        container_.Set({self.}XmlChildNum);
    end
    return {self.}XmlChildNum;
end;

function F.ReadXmlChildDen(): Den;
begin
    if tslassigning and (ifnil({self.}XmlChildDen) or {self.}XmlChildDen.Removed) then
    begin
        {self.}XmlChildDen := new Den(self, {self.}Prefix, "den");
        container_.Set({self.}XmlChildDen);
    end
    return {self.}XmlChildDen;
end;

function FPr.Create();overload;
begin
    {self.}Create(nil, "m", "fPr");
end;

function FPr.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function FPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "type": array(0, makeweakref(thisFunction(ReadXmlChildType))),
        pre + "ctrlPr": array(1, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function FPr.Copy(_obj: FPr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildType) then
        {self.}Type.Copy(_obj.XmlChildType);
    if not ifnil(_obj.XmlChildCtrlPr) then
        {self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
    tslassigning := tslassigning_backup;
end;

function FPr.ReadXmlChildType(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildType) or {self.}XmlChildType.Removed) then
    begin
        {self.}XmlChildType := new PureMVal(self, {self.}Prefix, "type");
        container_.Set({self.}XmlChildType);
    end
    return {self.}XmlChildType;
end;

function FPr.ReadXmlChildCtrlPr(): CtrlPr;
begin
    if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
    begin
        {self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
        container_.Set({self.}XmlChildCtrlPr);
    end
    return {self.}XmlChildCtrlPr;
end;

function Num.Create();overload;
begin
    {self.}Create(nil, "m", "num");
end;

function Num.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function Num.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "r": array(0, makeweakref(thisFunction(AppendR))),
        pre + "rad": array(1, makeweakref(thisFunction(ReadXmlChildRad))),
        pre + "ctrlPr": array(2, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
    );
    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.XmlChildRad) then
        {self.}Rad.Copy(_obj.XmlChildRad);
    if not ifnil(_obj.XmlChildCtrlPr) then
        {self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
    tslassigning := tslassigning_backup;
end;

function Num.ReadXmlChildRad(): Rad;
begin
    if tslassigning and (ifnil({self.}XmlChildRad) or {self.}XmlChildRad.Removed) then
    begin
        {self.}XmlChildRad := new Rad(self, {self.}Prefix, "rad");
        container_.Set({self.}XmlChildRad);
    end
    return {self.}XmlChildRad;
end;

function Num.ReadXmlChildCtrlPr(): CtrlPr;
begin
    if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
    begin
        {self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
        container_.Set({self.}XmlChildCtrlPr);
    end
    return {self.}XmlChildCtrlPr;
end;

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

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

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

function Rad.Create();overload;
begin
    {self.}Create(nil, "m", "rad");
end;

function Rad.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function Rad.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "radPr": array(0, makeweakref(thisFunction(ReadXmlChildRadPr))),
        pre + "deg": array(1, makeweakref(thisFunction(ReadXmlChildDeg))),
        pre + "e": array(2, makeweakref(thisFunction(ReadXmlChildE))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Rad.Copy(_obj: Rad);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildRadPr) then
        {self.}RadPr.Copy(_obj.XmlChildRadPr);
    if not ifnil(_obj.XmlChildDeg) then
        {self.}Deg.Copy(_obj.XmlChildDeg);
    if not ifnil(_obj.XmlChildE) then
        {self.}E.Copy(_obj.XmlChildE);
    tslassigning := tslassigning_backup;
end;

function Rad.ReadXmlChildRadPr(): RadPr;
begin
    if tslassigning and (ifnil({self.}XmlChildRadPr) or {self.}XmlChildRadPr.Removed) then
    begin
        {self.}XmlChildRadPr := new RadPr(self, {self.}Prefix, "radPr");
        container_.Set({self.}XmlChildRadPr);
    end
    return {self.}XmlChildRadPr;
end;

function Rad.ReadXmlChildDeg(): Deg;
begin
    if tslassigning and (ifnil({self.}XmlChildDeg) or {self.}XmlChildDeg.Removed) then
    begin
        {self.}XmlChildDeg := new Deg(self, {self.}Prefix, "deg");
        container_.Set({self.}XmlChildDeg);
    end
    return {self.}XmlChildDeg;
end;

function Rad.ReadXmlChildE(): E;
begin
    if tslassigning and (ifnil({self.}XmlChildE) or {self.}XmlChildE.Removed) then
    begin
        {self.}XmlChildE := new E(self, {self.}Prefix, "e");
        container_.Set({self.}XmlChildE);
    end
    return {self.}XmlChildE;
end;

function RadPr.Create();overload;
begin
    {self.}Create(nil, "m", "radPr");
end;

function RadPr.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function RadPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "degHide": array(0, makeweakref(thisFunction(ReadXmlChildDegHide))),
        pre + "ctrlPr": array(1, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function RadPr.Copy(_obj: RadPr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildDegHide) then
        {self.}DegHide.Copy(_obj.XmlChildDegHide);
    if not ifnil(_obj.XmlChildCtrlPr) then
        {self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
    tslassigning := tslassigning_backup;
end;

function RadPr.ReadXmlChildDegHide(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildDegHide) or {self.}XmlChildDegHide.Removed) then
    begin
        {self.}XmlChildDegHide := new PureMVal(self, {self.}Prefix, "degHide");
        container_.Set({self.}XmlChildDegHide);
    end
    return {self.}XmlChildDegHide;
end;

function RadPr.ReadXmlChildCtrlPr(): CtrlPr;
begin
    if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
    begin
        {self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
        container_.Set({self.}XmlChildCtrlPr);
    end
    return {self.}XmlChildCtrlPr;
end;

function Deg.Create();overload;
begin
    {self.}Create(nil, "m", "deg");
end;

function Deg.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

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

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

function Deg.ReadXmlChildCtrlPr(): CtrlPr;
begin
    if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
    begin
        {self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
        container_.Set({self.}XmlChildCtrlPr);
    end
    return {self.}XmlChildCtrlPr;
end;

function Den.Create();overload;
begin
    {self.}Create(nil, "m", "den");
end;

function Den.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

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

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

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

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

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

function SSub.Create();overload;
begin
    {self.}Create(nil, "m", "sSub");
end;

function SSub.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function SSub.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "sSubPr": array(0, makeweakref(thisFunction(ReadXmlChildSSubPr))),
        pre + "e": array(1, makeweakref(thisFunction(ReadXmlChildE))),
        pre + "sub": array(2, makeweakref(thisFunction(ReadXmlChildSub))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function SSub.Copy(_obj: SSub);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildSSubPr) then
        {self.}SSubPr.Copy(_obj.XmlChildSSubPr);
    if not ifnil(_obj.XmlChildE) then
        {self.}E.Copy(_obj.XmlChildE);
    if not ifnil(_obj.XmlChildSub) then
        {self.}Sub.Copy(_obj.XmlChildSub);
    tslassigning := tslassigning_backup;
end;

function SSub.ReadXmlChildSSubPr(): SSubPr;
begin
    if tslassigning and (ifnil({self.}XmlChildSSubPr) or {self.}XmlChildSSubPr.Removed) then
    begin
        {self.}XmlChildSSubPr := new SSubPr(self, {self.}Prefix, "sSubPr");
        container_.Set({self.}XmlChildSSubPr);
    end
    return {self.}XmlChildSSubPr;
end;

function SSub.ReadXmlChildE(): E;
begin
    if tslassigning and (ifnil({self.}XmlChildE) or {self.}XmlChildE.Removed) then
    begin
        {self.}XmlChildE := new E(self, {self.}Prefix, "e");
        container_.Set({self.}XmlChildE);
    end
    return {self.}XmlChildE;
end;

function SSub.ReadXmlChildSub(): Sub;
begin
    if tslassigning and (ifnil({self.}XmlChildSub) or {self.}XmlChildSub.Removed) then
    begin
        {self.}XmlChildSub := new Sub(self, {self.}Prefix, "sub");
        container_.Set({self.}XmlChildSub);
    end
    return {self.}XmlChildSub;
end;

function SSubPr.Create();overload;
begin
    {self.}Create(nil, "m", "sSubPr");
end;

function SSubPr.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

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

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

function SSubPr.ReadXmlChildCtrlPr(): CtrlPr;
begin
    if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
    begin
        {self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
        container_.Set({self.}XmlChildCtrlPr);
    end
    return {self.}XmlChildCtrlPr;
end;

function Sub.Create();overload;
begin
    {self.}Create(nil, "m", "sub");
end;

function Sub.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function Sub.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "r": array(0, makeweakref(thisFunction(AppendR))),
        pre + "ctrlPr": array(1, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

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

function Sub.ReadXmlChildCtrlPr(): CtrlPr;
begin
    if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
    begin
        {self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
        container_.Set({self.}XmlChildCtrlPr);
    end
    return {self.}XmlChildCtrlPr;
end;

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

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

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

function Nary.Create();overload;
begin
    {self.}Create(nil, "m", "nary");
end;

function Nary.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function Nary.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "naryPr": array(0, makeweakref(thisFunction(ReadXmlChildNaryPr))),
        pre + "sub": array(1, makeweakref(thisFunction(ReadXmlChildSub))),
        pre + "sup": array(2, makeweakref(thisFunction(ReadXmlChildSup))),
        pre + "e": array(3, makeweakref(thisFunction(ReadXmlChildE))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Nary.Copy(_obj: Nary);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildNaryPr) then
        {self.}NaryPr.Copy(_obj.XmlChildNaryPr);
    if not ifnil(_obj.XmlChildSub) then
        {self.}Sub.Copy(_obj.XmlChildSub);
    if not ifnil(_obj.XmlChildSup) then
        {self.}Sup.Copy(_obj.XmlChildSup);
    if not ifnil(_obj.XmlChildE) then
        {self.}E.Copy(_obj.XmlChildE);
    tslassigning := tslassigning_backup;
end;

function Nary.ReadXmlChildNaryPr(): NaryPr;
begin
    if tslassigning and (ifnil({self.}XmlChildNaryPr) or {self.}XmlChildNaryPr.Removed) then
    begin
        {self.}XmlChildNaryPr := new NaryPr(self, {self.}Prefix, "naryPr");
        container_.Set({self.}XmlChildNaryPr);
    end
    return {self.}XmlChildNaryPr;
end;

function Nary.ReadXmlChildSub(): Sub;
begin
    if tslassigning and (ifnil({self.}XmlChildSub) or {self.}XmlChildSub.Removed) then
    begin
        {self.}XmlChildSub := new Sub(self, {self.}Prefix, "sub");
        container_.Set({self.}XmlChildSub);
    end
    return {self.}XmlChildSub;
end;

function Nary.ReadXmlChildSup(): Sup;
begin
    if tslassigning and (ifnil({self.}XmlChildSup) or {self.}XmlChildSup.Removed) then
    begin
        {self.}XmlChildSup := new Sup(self, {self.}Prefix, "sup");
        container_.Set({self.}XmlChildSup);
    end
    return {self.}XmlChildSup;
end;

function Nary.ReadXmlChildE(): E;
begin
    if tslassigning and (ifnil({self.}XmlChildE) or {self.}XmlChildE.Removed) then
    begin
        {self.}XmlChildE := new E(self, {self.}Prefix, "e");
        container_.Set({self.}XmlChildE);
    end
    return {self.}XmlChildE;
end;

function NaryPr.Create();overload;
begin
    {self.}Create(nil, "m", "naryPr");
end;

function NaryPr.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function NaryPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "chr": array(0, makeweakref(thisFunction(ReadXmlChildChr))),
        pre + "grow": array(1, makeweakref(thisFunction(ReadXmlChildGrow))),
        pre + "subHide": array(2, makeweakref(thisFunction(ReadXmlChildSubHide))),
        pre + "supHide": array(3, makeweakref(thisFunction(ReadXmlChildSupHide))),
        pre + "limLoc": array(4, makeweakref(thisFunction(ReadXmlChildLimLoc))),
        pre + "ctrlPr": array(5, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function NaryPr.Copy(_obj: NaryPr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildChr) then
        {self.}Chr.Copy(_obj.XmlChildChr);
    if not ifnil(_obj.XmlChildGrow) then
        {self.}Grow.Copy(_obj.XmlChildGrow);
    if not ifnil(_obj.XmlChildSubHide) then
        {self.}SubHide.Copy(_obj.XmlChildSubHide);
    if not ifnil(_obj.XmlChildSupHide) then
        {self.}SupHide.Copy(_obj.XmlChildSupHide);
    if not ifnil(_obj.XmlChildLimLoc) then
        {self.}LimLoc.Copy(_obj.XmlChildLimLoc);
    if not ifnil(_obj.XmlChildCtrlPr) then
        {self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
    tslassigning := tslassigning_backup;
end;

function NaryPr.ReadXmlChildChr(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildChr) or {self.}XmlChildChr.Removed) then
    begin
        {self.}XmlChildChr := new PureMVal(self, {self.}Prefix, "chr");
        container_.Set({self.}XmlChildChr);
    end
    return {self.}XmlChildChr;
end;

function NaryPr.ReadXmlChildGrow(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildGrow) or {self.}XmlChildGrow.Removed) then
    begin
        {self.}XmlChildGrow := new PureMVal(self, {self.}Prefix, "grow");
        container_.Set({self.}XmlChildGrow);
    end
    return {self.}XmlChildGrow;
end;

function NaryPr.ReadXmlChildSubHide(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildSubHide) or {self.}XmlChildSubHide.Removed) then
    begin
        {self.}XmlChildSubHide := new PureMVal(self, {self.}Prefix, "subHide");
        container_.Set({self.}XmlChildSubHide);
    end
    return {self.}XmlChildSubHide;
end;

function NaryPr.ReadXmlChildSupHide(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildSupHide) or {self.}XmlChildSupHide.Removed) then
    begin
        {self.}XmlChildSupHide := new PureMVal(self, {self.}Prefix, "supHide");
        container_.Set({self.}XmlChildSupHide);
    end
    return {self.}XmlChildSupHide;
end;

function NaryPr.ReadXmlChildLimLoc(): PureMVal;
begin
    if tslassigning and (ifnil({self.}XmlChildLimLoc) or {self.}XmlChildLimLoc.Removed) then
    begin
        {self.}XmlChildLimLoc := new PureMVal(self, {self.}Prefix, "limLoc");
        container_.Set({self.}XmlChildLimLoc);
    end
    return {self.}XmlChildLimLoc;
end;

function NaryPr.ReadXmlChildCtrlPr(): CtrlPr;
begin
    if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
    begin
        {self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
        container_.Set({self.}XmlChildCtrlPr);
    end
    return {self.}XmlChildCtrlPr;
end;

function Func.Create();overload;
begin
    {self.}Create(nil, "m", "func");
end;

function Func.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function Func.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "funcPr": array(0, makeweakref(thisFunction(ReadXmlChildFuncPr))),
        pre + "fname": array(1, makeweakref(thisFunction(ReadXmlChildFName))),
        pre + "e": array(2, makeweakref(thisFunction(ReadXmlChildE))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Func.Copy(_obj: Func);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildFuncPr) then
        {self.}FuncPr.Copy(_obj.XmlChildFuncPr);
    if not ifnil(_obj.XmlChildFName) then
        {self.}FName.Copy(_obj.XmlChildFName);
    if not ifnil(_obj.XmlChildE) then
        {self.}E.Copy(_obj.XmlChildE);
    tslassigning := tslassigning_backup;
end;

function Func.ReadXmlChildFuncPr(): FuncPr;
begin
    if tslassigning and (ifnil({self.}XmlChildFuncPr) or {self.}XmlChildFuncPr.Removed) then
    begin
        {self.}XmlChildFuncPr := new FuncPr(self, {self.}Prefix, "funcPr");
        container_.Set({self.}XmlChildFuncPr);
    end
    return {self.}XmlChildFuncPr;
end;

function Func.ReadXmlChildFName(): FName;
begin
    if tslassigning and (ifnil({self.}XmlChildFName) or {self.}XmlChildFName.Removed) then
    begin
        {self.}XmlChildFName := new FName(self, {self.}Prefix, "fname");
        container_.Set({self.}XmlChildFName);
    end
    return {self.}XmlChildFName;
end;

function Func.ReadXmlChildE(): E;
begin
    if tslassigning and (ifnil({self.}XmlChildE) or {self.}XmlChildE.Removed) then
    begin
        {self.}XmlChildE := new E(self, {self.}Prefix, "e");
        container_.Set({self.}XmlChildE);
    end
    return {self.}XmlChildE;
end;

function FName.Create();overload;
begin
    {self.}Create(nil, "m", "fname");
end;

function FName.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

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

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

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

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

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

function FuncPr.Create();overload;
begin
    {self.}Create(nil, "m", "funcPr");
end;

function FuncPr.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

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

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

function FuncPr.ReadXmlChildCtrlPr(): CtrlPr;
begin
    if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
    begin
        {self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
        container_.Set({self.}XmlChildCtrlPr);
    end
    return {self.}XmlChildCtrlPr;
end;

function CoreProperties.Create();overload;
begin
    {self.}Create(nil, "cp", "coreProperties");
end;

function CoreProperties.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function CoreProperties.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        "dc:title": array(0, makeweakref(thisFunction(ReadXmlChildTitle))),
        "dc:subject": array(1, makeweakref(thisFunction(ReadXmlChildSubject))),
        "dc:creator": array(2, makeweakref(thisFunction(ReadXmlChildCreator))),
        "cp:keywords": array(3, makeweakref(thisFunction(ReadXmlChildKeywords))),
        "cp:description": array(4, makeweakref(thisFunction(ReadXmlChildDescription))),
        "cp:lastModifiedBy": array(5, makeweakref(thisFunction(ReadXmlChildLastModifiedBy))),
        "cp:revision": array(6, makeweakref(thisFunction(ReadXmlChildRevision))),
        "cp:lastPrinted": array(7, makeweakref(thisFunction(ReadXmlChildLastPrinted))),
        "dcterms:created": array(8, makeweakref(thisFunction(ReadXmlChildCreated))),
        "dcterms:modified": array(9, makeweakref(thisFunction(ReadXmlChildModified))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function CoreProperties.Copy(_obj: CoreProperties);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlCompositeElement).Copy(_obj);
    if not ifnil(_obj.XmlChildTitle) then
        {self.}Title.Copy(_obj.XmlChildTitle);
    if not ifnil(_obj.XmlChildSubject) then
        {self.}Subject.Copy(_obj.XmlChildSubject);
    if not ifnil(_obj.XmlChildCreator) then
        {self.}Creator.Copy(_obj.XmlChildCreator);
    if not ifnil(_obj.XmlChildKeywords) then
        {self.}Keywords.Copy(_obj.XmlChildKeywords);
    if not ifnil(_obj.XmlChildDescription) then
        {self.}Description.Copy(_obj.XmlChildDescription);
    if not ifnil(_obj.XmlChildLastModifiedBy) then
        {self.}LastModifiedBy.Copy(_obj.XmlChildLastModifiedBy);
    if not ifnil(_obj.XmlChildRevision) then
        {self.}Revision.Copy(_obj.XmlChildRevision);
    if not ifnil(_obj.XmlChildLastPrinted) then
        {self.}LastPrinted.Copy(_obj.XmlChildLastPrinted);
    if not ifnil(_obj.XmlChildCreated) then
        {self.}Created.Copy(_obj.XmlChildCreated);
    if not ifnil(_obj.XmlChildModified) then
        {self.}Modified.Copy(_obj.XmlChildModified);
    tslassigning := tslassigning_backup;
end;

function CoreProperties.ReadXmlChildTitle();
begin
    if tslassigning and (ifnil({self.}XmlChildTitle) or {self.}XmlChildTitle.Removed) then
    begin
        {self.}XmlChildTitle := new OpenXmlTextElement(self, "dc", "title");
        container_.Set({self.}XmlChildTitle);
    end
    return {self.}XmlChildTitle;
end;

function CoreProperties.ReadXmlChildSubject();
begin
    if tslassigning and (ifnil({self.}XmlChildSubject) or {self.}XmlChildSubject.Removed) then
    begin
        {self.}XmlChildSubject := new OpenXmlTextElement(self, "dc", "subject");
        container_.Set({self.}XmlChildSubject);
    end
    return {self.}XmlChildSubject;
end;

function CoreProperties.ReadXmlChildCreator();
begin
    if tslassigning and (ifnil({self.}XmlChildCreator) or {self.}XmlChildCreator.Removed) then
    begin
        {self.}XmlChildCreator := new OpenXmlTextElement(self, "dc", "creator");
        container_.Set({self.}XmlChildCreator);
    end
    return {self.}XmlChildCreator;
end;

function CoreProperties.ReadXmlChildKeywords();
begin
    if tslassigning and (ifnil({self.}XmlChildKeywords) or {self.}XmlChildKeywords.Removed) then
    begin
        {self.}XmlChildKeywords := new OpenXmlTextElement(self, "cp", "keywords");
        container_.Set({self.}XmlChildKeywords);
    end
    return {self.}XmlChildKeywords;
end;

function CoreProperties.ReadXmlChildDescription();
begin
    if tslassigning and (ifnil({self.}XmlChildDescription) or {self.}XmlChildDescription.Removed) then
    begin
        {self.}XmlChildDescription := new OpenXmlTextElement(self, "cp", "description");
        container_.Set({self.}XmlChildDescription);
    end
    return {self.}XmlChildDescription;
end;

function CoreProperties.ReadXmlChildLastModifiedBy();
begin
    if tslassigning and (ifnil({self.}XmlChildLastModifiedBy) or {self.}XmlChildLastModifiedBy.Removed) then
    begin
        {self.}XmlChildLastModifiedBy := new OpenXmlTextElement(self, "cp", "lastModifiedBy");
        container_.Set({self.}XmlChildLastModifiedBy);
    end
    return {self.}XmlChildLastModifiedBy;
end;

function CoreProperties.ReadXmlChildRevision();
begin
    if tslassigning and (ifnil({self.}XmlChildRevision) or {self.}XmlChildRevision.Removed) then
    begin
        {self.}XmlChildRevision := new OpenXmlTextElement(self, "cp", "revision");
        container_.Set({self.}XmlChildRevision);
    end
    return {self.}XmlChildRevision;
end;

function CoreProperties.ReadXmlChildLastPrinted();
begin
    if tslassigning and (ifnil({self.}XmlChildLastPrinted) or {self.}XmlChildLastPrinted.Removed) then
    begin
        {self.}XmlChildLastPrinted := new OpenXmlTextElement(self, "cp", "lastPrinted");
        container_.Set({self.}XmlChildLastPrinted);
    end
    return {self.}XmlChildLastPrinted;
end;

function CoreProperties.ReadXmlChildCreated();
begin
    if tslassigning and (ifnil({self.}XmlChildCreated) or {self.}XmlChildCreated.Removed) then
    begin
        {self.}XmlChildCreated := new Created(self, "dcterms", "created");
        container_.Set({self.}XmlChildCreated);
    end
    return {self.}XmlChildCreated;
end;

function CoreProperties.ReadXmlChildModified();
begin
    if tslassigning and (ifnil({self.}XmlChildModified) or {self.}XmlChildModified.Removed) then
    begin
        {self.}XmlChildModified := new Modified(self, "dcterms", "modified");
        container_.Set({self.}XmlChildModified);
    end
    return {self.}XmlChildModified;
end;

function Created.Create();overload;
begin
    {self.}Create(nil, "dcterms", "created");
end;

function Created.Create(_node: XmlNode);overload;
begin
    class(OpenXmlTextElement).Create(_node: XmlNode);
end;

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

function Created.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "xsi:type": makeweakref(thisFunction(WriteXmlAttrType)),
    );
end;

function Created.Copy(_obj: Created);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlTextElement).Copy(_obj);
    if not ifnil(_obj.Type) then
        {self.}Type := _obj.Type;
    tslassigning := tslassigning_backup;
end;

function Created.ReadXmlAttrType();
begin
    return {self.}XmlAttrType.Value;
end;

function Created.WriteXmlAttrType(_value);
begin
    if ifnil({self.}XmlAttrType) then
    begin
        {self.}XmlAttrType := new OpenXmlAttribute("xsi", "type", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrType;
    end
    {self.}XmlAttrType.Value := _value;
end;

function Modified.Create();overload;
begin
    {self.}Create(nil, "dcterms", "modified");
end;

function Modified.Create(_node: XmlNode);overload;
begin
    class(OpenXmlTextElement).Create(_node: XmlNode);
end;

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

function Modified.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "xsi:type": makeweakref(thisFunction(WriteXmlAttrType)),
    );
end;

function Modified.Copy(_obj: Modified);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlTextElement).Copy(_obj);
    if not ifnil(_obj.Type) then
        {self.}Type := _obj.Type;
    tslassigning := tslassigning_backup;
end;

function Modified.ReadXmlAttrType();
begin
    return {self.}XmlAttrType.Value;
end;

function Modified.WriteXmlAttrType(_value);
begin
    if ifnil({self.}XmlAttrType) then
    begin
        {self.}XmlAttrType := new OpenXmlAttribute("xsi", "type", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrType;
    end
    {self.}XmlAttrType.Value := _value;
end;

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

function Relationships.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

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

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

function Relationships.ReadRelationships(_index);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get("Relationship", ind);
end;

function Relationships.AddRelationship(): Relationship;
begin
    obj := new Relationship(self, "", "Relationship");
    container_.Insert(obj);
    return obj;
end;

function Relationships.AppendRelationship(): Relationship;
begin
    obj := new Relationship(self, "", "Relationship");
    container_.Append(obj);
    return obj;
end;

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

function Relationship.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function Relationship.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "Id": makeweakref(thisFunction(WriteXmlAttrId)),
        "Type": makeweakref(thisFunction(WriteXmlAttrType)),
        "Target": makeweakref(thisFunction(WriteXmlAttrTarget)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Relationship.Copy(_obj: Relationship);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.Type) then
        {self.}Type := _obj.Type;
    if not ifnil(_obj.Target) then
        {self.}Target := _obj.Target;
    tslassigning := tslassigning_backup;
end;

function Relationship.ReadXmlAttrId();
begin
    return {self.}XmlAttrId.Value;
end;

function Relationship.WriteXmlAttrId(_value);
begin
    if ifnil({self.}XmlAttrId) then
    begin
        {self.}XmlAttrId := new OpenXmlAttribute("", "Id", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrId;
    end
    {self.}XmlAttrId.Value := _value;
end;

function Relationship.ReadXmlAttrType();
begin
    return {self.}XmlAttrType.Value;
end;

function Relationship.WriteXmlAttrType(_value);
begin
    if ifnil({self.}XmlAttrType) then
    begin
        {self.}XmlAttrType := new OpenXmlAttribute("", "Type", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrType;
    end
    {self.}XmlAttrType.Value := _value;
end;

function Relationship.ReadXmlAttrTarget();
begin
    return {self.}XmlAttrTarget.Value;
end;

function Relationship.WriteXmlAttrTarget(_value);
begin
    if ifnil({self.}XmlAttrTarget) then
    begin
        {self.}XmlAttrTarget := new OpenXmlAttribute("", "Target", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrTarget;
    end
    {self.}XmlAttrTarget.Value := _value;
end;

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

function Types.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function Types.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        "Default": array(0, makeweakref(thisFunction(AppendDefault))),
        "Override": array(1, makeweakref(thisFunction(AppendOverride))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

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

function Types.ReadDefaults(_index);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get("Default", ind);
end;

function Types.ReadOverrides(_index);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get("Override", ind);
end;

function Types.AddDefault(): Default;
begin
    obj := new Default(self, "", "Default");
    container_.Insert(obj);
    return obj;
end;

function Types.AddOverride(): _Override;
begin
    obj := new _Override(self, "", "Override");
    container_.Insert(obj);
    return obj;
end;

function Types.AppendDefault(): Default;
begin
    obj := new Default(self, "", "Default");
    container_.Append(obj);
    return obj;
end;

function Types.AppendOverride(): _Override;
begin
    obj := new _Override(self, "", "Override");
    container_.Append(obj);
    return obj;
end;

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

function Default.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function Default.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "Extension": makeweakref(thisFunction(WriteXmlAttrExtension)),
        "ContentType": makeweakref(thisFunction(WriteXmlAttrContentType)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

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

function Default.ReadXmlAttrExtension();
begin
    return {self.}XmlAttrExtension.Value;
end;

function Default.WriteXmlAttrExtension(_value);
begin
    if ifnil({self.}XmlAttrExtension) then
    begin
        {self.}XmlAttrExtension := new OpenXmlAttribute("", "Extension", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrExtension;
    end
    {self.}XmlAttrExtension.Value := _value;
end;

function Default.ReadXmlAttrContentType();
begin
    return {self.}XmlAttrContentType.Value;
end;

function Default.WriteXmlAttrContentType(_value);
begin
    if ifnil({self.}XmlAttrContentType) then
    begin
        {self.}XmlAttrContentType := new OpenXmlAttribute("", "ContentType", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrContentType;
    end
    {self.}XmlAttrContentType.Value := _value;
end;

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

function _Override.Create(_node: XmlNode);overload;
begin
    class(OpenXmlCompositeElement).Create(_node: XmlNode);
end;

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

function _Override.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "PartName": makeweakref(thisFunction(WriteXmlAttrPartName)),
        "ContentType": makeweakref(thisFunction(WriteXmlAttrContentType)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

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

function _Override.ReadXmlAttrPartName();
begin
    return {self.}XmlAttrPartName.Value;
end;

function _Override.WriteXmlAttrPartName(_value);
begin
    if ifnil({self.}XmlAttrPartName) then
    begin
        {self.}XmlAttrPartName := new OpenXmlAttribute("", "PartName", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrPartName;
    end
    {self.}XmlAttrPartName.Value := _value;
end;

function _Override.ReadXmlAttrContentType();
begin
    return {self.}XmlAttrContentType.Value;
end;

function _Override.WriteXmlAttrContentType(_value);
begin
    if ifnil({self.}XmlAttrContentType) then
    begin
        {self.}XmlAttrContentType := new OpenXmlAttribute("", "ContentType", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrContentType;
    end
    {self.}XmlAttrContentType.Value := _value;
end;

end.