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

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

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

    // Children

end;

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

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

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

function Ind.Init();override;
begin
    {self.}XmlAttrFirstLineChars := new OpenXmlAttribute({self.}Prefix, "firstLineChars", nil);
    {self.}XmlAttrFirstLine := new OpenXmlAttribute({self.}Prefix, "firstLine", nil);
    {self.}XmlAttrRightChars := new OpenXmlAttribute({self.}Prefix, "rightChars", nil);
    {self.}XmlAttrRight := new OpenXmlAttribute({self.}Prefix, "right", nil);
    {self.}XmlAttrLeftChars := new OpenXmlAttribute({self.}Prefix, "leftChars", nil);
    {self.}XmlAttrLeft := new OpenXmlAttribute({self.}Prefix, "left", nil);
    {self.}XmlAttrHanging := new OpenXmlAttribute({self.}Prefix, "hainging", nil);
    {self.}XmlAttrHangingChars := new OpenXmlAttribute({self.}Prefix, "hangingChars", nil);
end;

function Ind.InitAttributes();override;
begin
    attributes_ := array(
        {self.}XmlAttrFirstLineChars,
        {self.}XmlAttrFirstLine,
        {self.}XmlAttrRightChars,
        {self.}XmlAttrRight,
        {self.}XmlAttrLeftChars,
        {self.}XmlAttrLeft,
        {self.}XmlAttrHanging,
        {self.}XmlAttrHangingChars,
    );
end;

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

function Ind.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 Ind.Copy(_obj: Ind);override;
begin
    if not ifnil(_obj.XmlAttrFirstLineChars.Value) then
        {self.}XmlAttrFirstLineChars.Value := _obj.XmlAttrFirstLineChars.Value;
    if not ifnil(_obj.XmlAttrFirstLine.Value) then
        {self.}XmlAttrFirstLine.Value := _obj.XmlAttrFirstLine.Value;
    if not ifnil(_obj.XmlAttrRightChars.Value) then
        {self.}XmlAttrRightChars.Value := _obj.XmlAttrRightChars.Value;
    if not ifnil(_obj.XmlAttrRight.Value) then
        {self.}XmlAttrRight.Value := _obj.XmlAttrRight.Value;
    if not ifnil(_obj.XmlAttrLeftChars.Value) then
        {self.}XmlAttrLeftChars.Value := _obj.XmlAttrLeftChars.Value;
    if not ifnil(_obj.XmlAttrLeft.Value) then
        {self.}XmlAttrLeft.Value := _obj.XmlAttrLeft.Value;
    if not ifnil(_obj.XmlAttrHanging.Value) then
        {self.}XmlAttrHanging.Value := _obj.XmlAttrHanging.Value;
    if not ifnil(_obj.XmlAttrHangingChars.Value) then
        {self.}XmlAttrHangingChars.Value := _obj.XmlAttrHangingChars.Value;
end;

function Ind.ReadXmlAttrFirstLineChars();
begin
    return {self.}XmlAttrFirstLineChars.Value;
end;

function Ind.WriteXmlAttrFirstLineChars(_value);
begin
    {self.}XmlAttrFirstLineChars.Value := _value;
end;

function Ind.ReadXmlAttrFirstLine();
begin
    return {self.}XmlAttrFirstLine.Value;
end;

function Ind.WriteXmlAttrFirstLine(_value);
begin
    {self.}XmlAttrFirstLine.Value := _value;
end;

function Ind.ReadXmlAttrRightChars();
begin
    return {self.}XmlAttrRightChars.Value;
end;

function Ind.WriteXmlAttrRightChars(_value);
begin
    {self.}XmlAttrRightChars.Value := _value;
end;

function Ind.ReadXmlAttrRight();
begin
    return {self.}XmlAttrRight.Value;
end;

function Ind.WriteXmlAttrRight(_value);
begin
    {self.}XmlAttrRight.Value := _value;
end;

function Ind.ReadXmlAttrLeftChars();
begin
    return {self.}XmlAttrLeftChars.Value;
end;

function Ind.WriteXmlAttrLeftChars(_value);
begin
    {self.}XmlAttrLeftChars.Value := _value;
end;

function Ind.ReadXmlAttrLeft();
begin
    return {self.}XmlAttrLeft.Value;
end;

function Ind.WriteXmlAttrLeft(_value);
begin
    {self.}XmlAttrLeft.Value := _value;
end;

function Ind.ReadXmlAttrHanging();
begin
    return {self.}XmlAttrHanging.Value;
end;

function Ind.WriteXmlAttrHanging(_value);
begin
    {self.}XmlAttrHanging.Value := _value;
end;

function Ind.ReadXmlAttrHangingChars();
begin
    return {self.}XmlAttrHangingChars.Value;
end;

function Ind.WriteXmlAttrHangingChars(_value);
begin
    {self.}XmlAttrHangingChars.Value := _value;
end;