type Ax = class(OpenXmlElement)
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: Ax);override;

public

    // normal property
    property AxId read ReadXmlChildAxId;
    property Scaling read ReadXmlChildScaling;
    property _Delete read ReadXmlChild_Delete;
    property AxPos read ReadXmlChildAxPos;
    property NumFmt read ReadXmlChildNumFmt;
    property MajorTickMark read ReadXmlChildMajorTickMark;
    property MinorTickMark read ReadXmlChildMinorTickMark;
    property TickLblPos read ReadXmlChildTickLblPos;
    property SpPr read ReadXmlChildSpPr;
    property TxPr read ReadXmlChildTxPr;
    property CrossAx read ReadXmlChildCrossAx;
    property Crosses read ReadXmlChildCrosses;
    property CrossBetween read ReadXmlChildCrossBetween;
    property Auto read ReadXmlChildAuto;
    property LblAlgn read ReadXmlChildLblAlgn;
    property LblOffset read ReadXmlChildLblOffset;
    property NoMultiLvlLbl read ReadXmlChildNoMultiLvlLbl;
    function ReadXmlChildAxId();
    function ReadXmlChildScaling();
    function ReadXmlChild_Delete();
    function ReadXmlChildAxPos();
    function ReadXmlChildNumFmt();
    function ReadXmlChildMajorTickMark();
    function ReadXmlChildMinorTickMark();
    function ReadXmlChildTickLblPos();
    function ReadXmlChildSpPr();
    function ReadXmlChildTxPr();
    function ReadXmlChildCrossAx();
    function ReadXmlChildCrosses();
    function ReadXmlChildCrossBetween();
    function ReadXmlChildAuto();
    function ReadXmlChildLblAlgn();
    function ReadXmlChildLblOffset();
    function ReadXmlChildNoMultiLvlLbl();

public
    // Children
    XmlChildAxId: PureVal;
    XmlChildScaling: Scaling;
    XmlChild_Delete: PureVal;
    XmlChildAxPos: PureVal;
    XmlChildNumFmt: NumFmt;
    XmlChildMajorTickMark: PureVal;
    XmlChildMinorTickMark: PureVal;
    XmlChildTickLblPos: PureVal;
    XmlChildSpPr: SpPr;
    XmlChildTxPr: TxPr;
    XmlChildCrossAx: PureVal;
    XmlChildCrosses: PureVal;
    XmlChildCrossBetween: PureVal;
    XmlChildAuto: PureVal;
    XmlChildLblAlgn: PureVal;
    XmlChildLblOffset: PureVal;
    XmlChildNoMultiLvlLbl: PureVal;

end;

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

function Ax.Create(_node: XmlNode);overload;
begin
    class(OpenXmlElement).Create(_node: XmlNode);
end;

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

function Ax.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "axId": array(0, makeweakref(thisFunction(ReadXmlChildAxId))),
        pre + "scaling": array(1, makeweakref(thisFunction(ReadXmlChildScaling))),
        pre + "delete": array(2, makeweakref(thisFunction(ReadXmlChild_Delete))),
        pre + "axPos": array(3, makeweakref(thisFunction(ReadXmlChildAxPos))),
        pre + "numFmt": array(4, makeweakref(thisFunction(ReadXmlChildNumFmt))),
        pre + "majorTickMark": array(5, makeweakref(thisFunction(ReadXmlChildMajorTickMark))),
        pre + "minorTickMark": array(6, makeweakref(thisFunction(ReadXmlChildMinorTickMark))),
        pre + "tickLblPos": array(7, makeweakref(thisFunction(ReadXmlChildTickLblPos))),
        pre + "spPr": array(8, makeweakref(thisFunction(ReadXmlChildSpPr))),
        pre + "txPr": array(9, makeweakref(thisFunction(ReadXmlChildTxPr))),
        pre + "crossAx": array(10, makeweakref(thisFunction(ReadXmlChildCrossAx))),
        pre + "crosses": array(11, makeweakref(thisFunction(ReadXmlChildCrosses))),
        pre + "crossBetween": array(12, makeweakref(thisFunction(ReadXmlChildCrossBetween))),
        pre + "auto": array(13, makeweakref(thisFunction(ReadXmlChildAuto))),
        pre + "lblAlgn": array(14, makeweakref(thisFunction(ReadXmlChildLblAlgn))),
        pre + "lblOffset": array(15, makeweakref(thisFunction(ReadXmlChildLblOffset))),
        pre + "noMultiLvlLbl": array(16, makeweakref(thisFunction(ReadXmlChildNoMultiLvlLbl))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Ax.Copy(_obj: Ax);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlElement).Copy(_obj);
    if not ifnil(_obj.XmlChildAxId) then
        {self.}AxId.Copy(_obj.XmlChildAxId);
    if not ifnil(_obj.XmlChildScaling) then
        {self.}Scaling.Copy(_obj.XmlChildScaling);
    if not ifnil(_obj.XmlChild_Delete) then
        {self.}_Delete.Copy(_obj.XmlChild_Delete);
    if not ifnil(_obj.XmlChildAxPos) then
        {self.}AxPos.Copy(_obj.XmlChildAxPos);
    if not ifnil(_obj.XmlChildNumFmt) then
        {self.}NumFmt.Copy(_obj.XmlChildNumFmt);
    if not ifnil(_obj.XmlChildMajorTickMark) then
        {self.}MajorTickMark.Copy(_obj.XmlChildMajorTickMark);
    if not ifnil(_obj.XmlChildMinorTickMark) then
        {self.}MinorTickMark.Copy(_obj.XmlChildMinorTickMark);
    if not ifnil(_obj.XmlChildTickLblPos) then
        {self.}TickLblPos.Copy(_obj.XmlChildTickLblPos);
    if not ifnil(_obj.XmlChildSpPr) then
        {self.}SpPr.Copy(_obj.XmlChildSpPr);
    if not ifnil(_obj.XmlChildTxPr) then
        {self.}TxPr.Copy(_obj.XmlChildTxPr);
    if not ifnil(_obj.XmlChildCrossAx) then
        {self.}CrossAx.Copy(_obj.XmlChildCrossAx);
    if not ifnil(_obj.XmlChildCrosses) then
        {self.}Crosses.Copy(_obj.XmlChildCrosses);
    if not ifnil(_obj.XmlChildCrossBetween) then
        {self.}CrossBetween.Copy(_obj.XmlChildCrossBetween);
    if not ifnil(_obj.XmlChildAuto) then
        {self.}Auto.Copy(_obj.XmlChildAuto);
    if not ifnil(_obj.XmlChildLblAlgn) then
        {self.}LblAlgn.Copy(_obj.XmlChildLblAlgn);
    if not ifnil(_obj.XmlChildLblOffset) then
        {self.}LblOffset.Copy(_obj.XmlChildLblOffset);
    if not ifnil(_obj.XmlChildNoMultiLvlLbl) then
        {self.}NoMultiLvlLbl.Copy(_obj.XmlChildNoMultiLvlLbl);
    tslassigning := tslassigning_backup;
end;

function Ax.ReadXmlChildAxId();
begin
    if tslassigning and ifnil({self.}XmlChildAxId) then
    begin
        {self.}XmlChildAxId := new PureVal(self, {self.}Prefix, "axId");
        container_.Set({self.}XmlChildAxId);
    end
    return {self.}XmlChildAxId;
end;

function Ax.ReadXmlChildScaling();
begin
    if tslassigning and ifnil({self.}XmlChildScaling) then
    begin
        {self.}XmlChildScaling := new Scaling(self, {self.}Prefix, "scaling");
        container_.Set({self.}XmlChildScaling);
    end
    return {self.}XmlChildScaling;
end;

function Ax.ReadXmlChild_Delete();
begin
    if tslassigning and ifnil({self.}XmlChild_Delete) then
    begin
        {self.}XmlChild_Delete := new PureVal(self, {self.}Prefix, "delete");
        container_.Set({self.}XmlChild_Delete);
    end
    return {self.}XmlChild_Delete;
end;

function Ax.ReadXmlChildAxPos();
begin
    if tslassigning and ifnil({self.}XmlChildAxPos) then
    begin
        {self.}XmlChildAxPos := new PureVal(self, {self.}Prefix, "axPos");
        container_.Set({self.}XmlChildAxPos);
    end
    return {self.}XmlChildAxPos;
end;

function Ax.ReadXmlChildNumFmt();
begin
    if tslassigning and ifnil({self.}XmlChildNumFmt) then
    begin
        {self.}XmlChildNumFmt := new NumFmt(self, {self.}Prefix, "numFmt");
        container_.Set({self.}XmlChildNumFmt);
    end
    return {self.}XmlChildNumFmt;
end;

function Ax.ReadXmlChildMajorTickMark();
begin
    if tslassigning and ifnil({self.}XmlChildMajorTickMark) then
    begin
        {self.}XmlChildMajorTickMark := new PureVal(self, {self.}Prefix, "majorTickMark");
        container_.Set({self.}XmlChildMajorTickMark);
    end
    return {self.}XmlChildMajorTickMark;
end;

function Ax.ReadXmlChildMinorTickMark();
begin
    if tslassigning and ifnil({self.}XmlChildMinorTickMark) then
    begin
        {self.}XmlChildMinorTickMark := new PureVal(self, {self.}Prefix, "minorTickMark");
        container_.Set({self.}XmlChildMinorTickMark);
    end
    return {self.}XmlChildMinorTickMark;
end;

function Ax.ReadXmlChildTickLblPos();
begin
    if tslassigning and ifnil({self.}XmlChildTickLblPos) then
    begin
        {self.}XmlChildTickLblPos := new PureVal(self, {self.}Prefix, "tickLblPos");
        container_.Set({self.}XmlChildTickLblPos);
    end
    return {self.}XmlChildTickLblPos;
end;

function Ax.ReadXmlChildSpPr();
begin
    if tslassigning and ifnil({self.}XmlChildSpPr) then
    begin
        {self.}XmlChildSpPr := new SpPr(self, {self.}Prefix, "spPr");
        container_.Set({self.}XmlChildSpPr);
    end
    return {self.}XmlChildSpPr;
end;

function Ax.ReadXmlChildTxPr();
begin
    if tslassigning and ifnil({self.}XmlChildTxPr) then
    begin
        {self.}XmlChildTxPr := new TxPr(self, {self.}Prefix, "txPr");
        container_.Set({self.}XmlChildTxPr);
    end
    return {self.}XmlChildTxPr;
end;

function Ax.ReadXmlChildCrossAx();
begin
    if tslassigning and ifnil({self.}XmlChildCrossAx) then
    begin
        {self.}XmlChildCrossAx := new PureVal(self, {self.}Prefix, "crossAx");
        container_.Set({self.}XmlChildCrossAx);
    end
    return {self.}XmlChildCrossAx;
end;

function Ax.ReadXmlChildCrosses();
begin
    if tslassigning and ifnil({self.}XmlChildCrosses) then
    begin
        {self.}XmlChildCrosses := new PureVal(self, {self.}Prefix, "crosses");
        container_.Set({self.}XmlChildCrosses);
    end
    return {self.}XmlChildCrosses;
end;

function Ax.ReadXmlChildCrossBetween();
begin
    if tslassigning and ifnil({self.}XmlChildCrossBetween) then
    begin
        {self.}XmlChildCrossBetween := new PureVal(self, {self.}Prefix, "crossBetween");
        container_.Set({self.}XmlChildCrossBetween);
    end
    return {self.}XmlChildCrossBetween;
end;

function Ax.ReadXmlChildAuto();
begin
    if tslassigning and ifnil({self.}XmlChildAuto) then
    begin
        {self.}XmlChildAuto := new PureVal(self, {self.}Prefix, "auto");
        container_.Set({self.}XmlChildAuto);
    end
    return {self.}XmlChildAuto;
end;

function Ax.ReadXmlChildLblAlgn();
begin
    if tslassigning and ifnil({self.}XmlChildLblAlgn) then
    begin
        {self.}XmlChildLblAlgn := new PureVal(self, {self.}Prefix, "lblAlgn");
        container_.Set({self.}XmlChildLblAlgn);
    end
    return {self.}XmlChildLblAlgn;
end;

function Ax.ReadXmlChildLblOffset();
begin
    if tslassigning and ifnil({self.}XmlChildLblOffset) then
    begin
        {self.}XmlChildLblOffset := new PureVal(self, {self.}Prefix, "lblOffset");
        container_.Set({self.}XmlChildLblOffset);
    end
    return {self.}XmlChildLblOffset;
end;

function Ax.ReadXmlChildNoMultiLvlLbl();
begin
    if tslassigning and ifnil({self.}XmlChildNoMultiLvlLbl) then
    begin
        {self.}XmlChildNoMultiLvlLbl := new PureVal(self, {self.}Prefix, "noMultiLvlLbl");
        container_.Set({self.}XmlChildNoMultiLvlLbl);
    end
    return {self.}XmlChildNoMultiLvlLbl;
end;