type Spacing = 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 InitAttributes();override;
    function InitChildren();override;
    function InitNode(_node: XmlNode);override;
    function Copy(_obj: Spacing);override;

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

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

    // Children

end;

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

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

function Spacing.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
    class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Spacing.Init();override;
begin
    {self.}XmlAttrBefore := new OpenXmlAttribute({self.}Prefix, "before", nil);
    {self.}XmlAttrBeforeLines := new OpenXmlAttribute({self.}Prefix, "beforeLines", nil);
    {self.}XmlAttrBeforeAutospacing := new OpenXmlAttribute({self.}Prefix, "beforeAutospacing", nil);
    {self.}XmlAttrAfter := new OpenXmlAttribute({self.}Prefix, "after", nil);
    {self.}XmlAttrAfterLines := new OpenXmlAttribute({self.}Prefix, "afterLines", nil);
    {self.}XmlAttrAfterAutospacing := new OpenXmlAttribute({self.}Prefix, "afterAutospacing", nil);
    {self.}XmlAttrLine := new OpenXmlAttribute({self.}Prefix, "line", nil);
    {self.}XmlAttrLineRule := new OpenXmlAttribute({self.}Prefix, "lineRule", nil);
end;

function Spacing.InitAttributes();override;
begin
    attributes_ := array(
        {self.}XmlAttrBefore,
        {self.}XmlAttrBeforeLines,
        {self.}XmlAttrBeforeAutospacing,
        {self.}XmlAttrAfter,
        {self.}XmlAttrAfterLines,
        {self.}XmlAttrAfterAutospacing,
        {self.}XmlAttrLine,
        {self.}XmlAttrLineRule,
    );
end;

function Spacing.InitChildren();override;
begin
    child_elements_ := array(
    );
    sorted_child_ := array(
        "": -1,
    );
end;

function Spacing.InitNode(_node: XmlNode);override;
begin
    if ifObj({self.}XmlNode) then
        for k,v in child_elements_ do v.InitNode(nil);
    {self.}XmlNode := ifObj(_node) ? _node : nil;
end;

function Spacing.Copy(_obj: Spacing);override;
begin
    if not ifnil(_obj.XmlAttrBefore.Value) then
        {self.}XmlAttrBefore.Value := _obj.XmlAttrBefore.Value;
    if not ifnil(_obj.XmlAttrBeforeLines.Value) then
        {self.}XmlAttrBeforeLines.Value := _obj.XmlAttrBeforeLines.Value;
    if not ifnil(_obj.XmlAttrBeforeAutospacing.Value) then
        {self.}XmlAttrBeforeAutospacing.Value := _obj.XmlAttrBeforeAutospacing.Value;
    if not ifnil(_obj.XmlAttrAfter.Value) then
        {self.}XmlAttrAfter.Value := _obj.XmlAttrAfter.Value;
    if not ifnil(_obj.XmlAttrAfterLines.Value) then
        {self.}XmlAttrAfterLines.Value := _obj.XmlAttrAfterLines.Value;
    if not ifnil(_obj.XmlAttrAfterAutospacing.Value) then
        {self.}XmlAttrAfterAutospacing.Value := _obj.XmlAttrAfterAutospacing.Value;
    if not ifnil(_obj.XmlAttrLine.Value) then
        {self.}XmlAttrLine.Value := _obj.XmlAttrLine.Value;
    if not ifnil(_obj.XmlAttrLineRule.Value) then
        {self.}XmlAttrLineRule.Value := _obj.XmlAttrLineRule.Value;
end;

function Spacing.ReadXmlAttrBefore();
begin
    return {self.}XmlAttrBefore.Value;
end;

function Spacing.WriteXmlAttrBefore(_value);
begin
    {self.}XmlAttrBefore.Value := _value;
end;

function Spacing.ReadXmlAttrBeforeLines();
begin
    return {self.}XmlAttrBeforeLines.Value;
end;

function Spacing.WriteXmlAttrBeforeLines(_value);
begin
    {self.}XmlAttrBeforeLines.Value := _value;
end;

function Spacing.ReadXmlAttrBeforeAutospacing();
begin
    return {self.}XmlAttrBeforeAutospacing.Value;
end;

function Spacing.WriteXmlAttrBeforeAutospacing(_value);
begin
    {self.}XmlAttrBeforeAutospacing.Value := _value;
end;

function Spacing.ReadXmlAttrAfter();
begin
    return {self.}XmlAttrAfter.Value;
end;

function Spacing.WriteXmlAttrAfter(_value);
begin
    {self.}XmlAttrAfter.Value := _value;
end;

function Spacing.ReadXmlAttrAfterLines();
begin
    return {self.}XmlAttrAfterLines.Value;
end;

function Spacing.WriteXmlAttrAfterLines(_value);
begin
    {self.}XmlAttrAfterLines.Value := _value;
end;

function Spacing.ReadXmlAttrAfterAutospacing();
begin
    return {self.}XmlAttrAfterAutospacing.Value;
end;

function Spacing.WriteXmlAttrAfterAutospacing(_value);
begin
    {self.}XmlAttrAfterAutospacing.Value := _value;
end;

function Spacing.ReadXmlAttrLine();
begin
    return {self.}XmlAttrLine.Value;
end;

function Spacing.WriteXmlAttrLine(_value);
begin
    {self.}XmlAttrLine.Value := _value;
end;

function Spacing.ReadXmlAttrLineRule();
begin
    return {self.}XmlAttrLineRule.Value;
end;

function Spacing.WriteXmlAttrLineRule(_value);
begin
    {self.}XmlAttrLineRule.Value := _value;
end;