PDF4QT/Pdf4QtLib/sources/pdfxfaengine.cpp

//    Copyright (C) 2021 Jakub Melka
//
//    This file is part of PDF4QT.
//
//    PDF4QT is free software: you can redistribute it and/or modify
//    it under the terms of the GNU Lesser General Public License as published by
//    the Free Software Foundation, either version 3 of the License, or
//    with the written consent of the copyright owner, any later version.
//
//    PDF4QT is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public License
//    along with PDF4QT.  If not, see <https://www.gnu.org/licenses/>.

#include "pdfxfaengine.h"

#include <QDomElement>

#include <optional>

namespace pdf
{

namespace xfa
{
struct XFA_InplaceTag;
struct XFA_SharedMemoryTag;

template<typename Value, typename Tag>
class PDFXFAValueHolder
{
public:
    inline constexpr PDFXFAValueHolder() = default;

    constexpr inline bool hasValue() const { return false; }
    constexpr const Value* getValue() const { return nullptr; }
};

template<typename Value>
class PDFXFAValueHolder<Value, XFA_InplaceTag>
{
public:
    inline constexpr PDFXFAValueHolder() = default;

    inline constexpr PDFXFAValueHolder(std::optional<Value> value) :
        m_value(std::move(value))
    {

    }

    constexpr inline bool hasValue() const { return m_value.has_value(); }
    constexpr const Value* getValue() const { return m_value.has_value() ? &m_value.value() : nullptr; }

private:
    std::optional<Value> m_value;
};

template<typename Value>
class PDFXFAValueHolder<Value, XFA_SharedMemoryTag>
{
public:
    inline constexpr PDFXFAValueHolder() = default;

    inline constexpr PDFXFAValueHolder(std::optional<Value> value) :
        m_value()
    {
        if (value)
        {
            m_value = std::make_shared<Value>(std::move(*value));
        }
    }

    constexpr inline bool hasValue() const { return m_value; }
    constexpr const Value* getValue() const { return m_value.get(); }

private:
    std::shared_ptr<Value> m_value;
};

template<typename Value>
using XFA_Attribute = PDFXFAValueHolder<Value, XFA_InplaceTag>;

template<typename Value>
using XFA_Node = PDFXFAValueHolder<Value, XFA_SharedMemoryTag>;

template<typename Value>
using XFA_Value = PDFXFAValueHolder<Value, XFA_InplaceTag>;

class XFA_Measurement
{
public:
    enum Type
    {
        in,
        cm,
        mm,
        pt,
        em,
        percent
    };

    constexpr inline XFA_Measurement() :
        m_value(0.0),
        m_type(in)
    {

    }

    constexpr inline XFA_Measurement(PDFReal value, Type type) :
        m_value(value),
        m_type(type)
    {

    }

    constexpr inline XFA_Measurement(PDFReal value) :
        m_value(value),
        m_type(in)
    {

    }

    constexpr PDFReal getValue() const { return m_value; }
    constexpr Type getType() const { return m_type; }

private:
    PDFReal m_value;
    Type m_type;
};

class XFA_AbstractNode
{
public:
    constexpr inline XFA_AbstractNode() = default;
    virtual ~XFA_AbstractNode() = default;

    template<typename Type>
    static void parseItem(const QDomElement& element, QString value, XFA_Node<Type>& node)
    {
        // Jakub Melka: set node value to null
        node = XFA_Node<Type>();

        QDomNodeList elements = element.elementsByTagName(value);
        if (!elements.isEmpty())
        {
            node = XFA_Node<Type>(Type::parse(elements.item(0).toElement()));
        }
    }

    template<typename Type>
    static void parseItem(const QDomElement& element, QString value, std::vector<XFA_Node<Type>>& nodes)
    {
        // Jakub Melka: clear node list
        nodes.clear();

        QDomNodeList elements = element.elementsByTagName(value);
        if (!elements.isEmpty())
        {
            nodes.resize(elements.size());
            for (int i = 0; i < elements.size(); ++i)
            {
                nodes[i] = XFA_Node<Type>(Type::parse(elements.item(i).toElement()));
            }
        }
    }

    template<typename Enum>
    static void parseEnumAttribute(const QDomElement& element,
                                   QString attributeFieldName,
                                   XFA_Attribute<Enum>& attribute,
                                   QString defaultValue,
                                   const auto& enumValues)
    {
        attribute = XFA_Attribute<Enum>();
        QString value = element.attribute(attributeFieldName, defaultValue);

        for (const auto& enumValue : enumValues)
        {
            if (enumValue.second == value)
            {
                attribute = XFA_Attribute<Enum>(enumValue.first);
                break;
            }
        }
    }

    static void parseAttribute(const QDomElement& element,
                               QString attributeFieldName,
                               XFA_Attribute<QString>& attribute,
                               QString defaultValue)
    {
        attribute = XFA_Attribute<QString>(element.attribute(attributeFieldName, defaultValue));
    }

    static void parseAttribute(const QDomElement& element,
                               QString attributeFieldName,
                               XFA_Attribute<bool>& attribute,
                               QString defaultValue)
    {
        attribute = XFA_Attribute<bool>(element.attribute(attributeFieldName, defaultValue).toInt() != 0);
    }

    static void parseAttribute(const QDomElement& element,
                               QString attributeFieldName,
                               XFA_Attribute<PDFReal>& attribute,
                               QString defaultValue)
    {
        attribute = XFA_Attribute<PDFReal>(element.attribute(attributeFieldName, defaultValue).toDouble());
    }

    static void parseAttribute(const QDomElement& element,
                               QString attributeFieldName,
                               XFA_Attribute<PDFInteger>& attribute,
                               QString defaultValue)
    {
        attribute = XFA_Attribute<PDFInteger>(element.attribute(attributeFieldName, defaultValue).toInt());
    }

    static void parseAttribute(const QDomElement& element,
                               QString attributeFieldName,
                               XFA_Attribute<XFA_Measurement>& attribute,
                               QString defaultValue)
    {
        attribute = XFA_Attribute<XFA_Measurement>();

        QString measurement = element.attribute(attributeFieldName, defaultValue);
        XFA_Measurement::Type measurementType = XFA_Measurement::Type::in;

        constexpr std::array measurementUnits = {
            std::make_pair(XFA_Measurement::Type::in, "in"),
            std::make_pair(XFA_Measurement::Type::pt, "pt"),
            std::make_pair(XFA_Measurement::Type::cm, "cm"),
            std::make_pair(XFA_Measurement::Type::mm, "mm"),
            std::make_pair(XFA_Measurement::Type::em, "em"),
            std::make_pair(XFA_Measurement::Type::percent, "%")
        };

        for (const auto& measurementUnit : measurementUnits)
        {
            QLatin1String unit(measurementUnit.second);
            if (measurement.endsWith(unit))
            {
                measurementType = measurementUnit.first;
                measurement.chop(unit.size());
                break;
            }
        }

        bool ok = false;
        PDFReal value = measurement.toDouble(&ok);

        if (ok)
        {
            attribute = XFA_Attribute<XFA_Measurement>(XFA_Measurement(value, measurementType));
        }
    }
};

}   // namespace xfa

/* START GENERATED CODE */

namespace xfa
{

class XFA_appearanceFilter;
class XFA_arc;
class XFA_area;
class XFA_assist;
class XFA_barcode;
class XFA_bind;
class XFA_bindItems;
class XFA_bookend;
class XFA_boolean;
class XFA_border;
class XFA_break;
class XFA_breakAfter;
class XFA_breakBefore;
class XFA_button;
class XFA_calculate;
class XFA_caption;
class XFA_certificate;
class XFA_certificates;
class XFA_checkButton;
class XFA_choiceList;
class XFA_color;
class XFA_comb;
class XFA_connect;
class XFA_contentArea;
class XFA_corner;
class XFA_date;
class XFA_dateTime;
class XFA_dateTimeEdit;
class XFA_decimal;
class XFA_defaultUi;
class XFA_desc;
class XFA_digestMethod;
class XFA_digestMethods;
class XFA_draw;
class XFA_edge;
class XFA_encoding;
class XFA_encodings;
class XFA_encrypt;
class XFA_encryptData;
class XFA_encryption;
class XFA_encryptionMethod;
class XFA_encryptionMethods;
class XFA_event;
class XFA_exData;
class XFA_exObject;
class XFA_exclGroup;
class XFA_execute;
class XFA_extras;
class XFA_field;
class XFA_fill;
class XFA_filter;
class XFA_float;
class XFA_font;
class XFA_format;
class XFA_handler;
class XFA_hyphenation;
class XFA_image;
class XFA_imageEdit;
class XFA_integer;
class XFA_issuers;
class XFA_items;
class XFA_keep;
class XFA_keyUsage;
class XFA_line;
class XFA_linear;
class XFA_lockDocument;
class XFA_manifest;
class XFA_margin;
class XFA_mdp;
class XFA_medium;
class XFA_message;
class XFA_numericEdit;
class XFA_occur;
class XFA_oid;
class XFA_oids;
class XFA_overflow;
class XFA_pageArea;
class XFA_pageSet;
class XFA_para;
class XFA_passwordEdit;
class XFA_pattern;
class XFA_picture;
class XFA_proto;
class XFA_radial;
class XFA_reason;
class XFA_reasons;
class XFA_rectangle;
class XFA_ref;
class XFA_script;
class XFA_setProperty;
class XFA_signData;
class XFA_signature;
class XFA_signing;
class XFA_solid;
class XFA_speak;
class XFA_stipple;
class XFA_subform;
class XFA_subformSet;
class XFA_subjectDN;
class XFA_subjectDNs;
class XFA_submit;
class XFA_template;
class XFA_text;
class XFA_textEdit;
class XFA_time;
class XFA_timeStamp;
class XFA_toolTip;
class XFA_traversal;
class XFA_traverse;
class XFA_ui;
class XFA_validate;
class XFA_value;
class XFA_variables;

class XFA_BaseNode : public XFA_AbstractNode
{
public:
    using XFA_AbstractNode::parseAttribute;

    enum class ACCESS
    {
        Open,
        NonInteractive,
        Protected,
        ReadOnly,
    };

    enum class ACTION
    {
        Include,
        All,
        Exclude,
    };

    enum class ACTIVITY
    {
        Click,
        Change,
        DocClose,
        DocReady,
        Enter,
        Exit,
        Full,
        IndexChange,
        Initialize,
        MouseDown,
        MouseEnter,
        MouseExit,
        MouseUp,
        PostExecute,
        PostOpen,
        PostPrint,
        PostSave,
        PostSign,
        PostSubmit,
        PreExecute,
        PreOpen,
        PrePrint,
        PreSave,
        PreSign,
        PreSubmit,
        Ready,
        ValidationState,
    };

    enum class AFTER
    {
        Auto,
        ContentArea,
        PageArea,
        PageEven,
        PageOdd,
    };

    enum class ANCHORTYPE
    {
        TopLeft,
        BottomCenter,
        BottomLeft,
        BottomRight,
        MiddleCenter,
        MiddleLeft,
        MiddleRight,
        TopCenter,
        TopRight,
    };

    enum class ASPECT
    {
        Fit,
        Actual,
        Height,
        None,
        Width,
    };

    enum class BASEPROFILE
    {
        Full,
        InteractiveForms,
    };

    enum class BEFORE
    {
        Auto,
        ContentArea,
        PageArea,
        PageEven,
        PageOdd,
    };

    enum class BLANKORNOTBLANK
    {
        Any,
        Blank,
        NotBlank,
    };

    enum class BREAK
    {
        Close,
        Open,
    };

    enum class CAP
    {
        Square,
        Butt,
        Round,
    };

    enum class CHECKSUM
    {
        None,
        _1mod10,
        _1mod10_1mod11,
        _2mod10,
        Auto,
    };

    enum class COMMITON
    {
        Select,
        Exit,
    };

    enum class CREDENTIALSERVERPOLICY
    {
        Optional,
        Required,
    };

    enum class DATAPREP
    {
        None,
        FlateCompress,
    };

    enum class DATA
    {
        Link,
        Embed,
    };

    enum class DUPLEXIMPOSITION
    {
        LongEdge,
        ShortEdge,
    };

    enum class EXECUTETYPE
    {
        Import,
        Remerge,
    };

    enum class FORMATTEST
    {
        Warning,
        Disabled,
        Error,
    };

    enum class FORMAT
    {
        Xdp,
        Formdata,
        Pdf,
        Urlencoded,
        Xfd,
        Xml,
    };

    enum class HALIGN
    {
        Left,
        Center,
        Justify,
        JustifyAll,
        Radix,
        Right,
    };

    enum class HSCROLLPOLICY
    {
        Auto,
        Off,
        On,
    };

    enum class HAND
    {
        Even,
        Left,
        Right,
    };

    enum class HIGHLIGHT
    {
        Inverted,
        None,
        Outline,
        Push,
    };

    enum class INTACT
    {
        None,
        ContentArea,
        PageArea,
    };

    enum class JOIN
    {
        Square,
        Round,
    };

    enum class KERNINGMODE
    {
        None,
        Pair,
    };

    enum class LAYOUT
    {
        Position,
        Lr_tb,
        Rl_row,
        Rl_tb,
        Row,
        Table,
        Tb,
    };

    enum class LINETHROUGHPERIOD
    {
        All,
        Word,
    };

    enum class LINETHROUGH
    {
        _0,
        _1,
        _2,
    };

    enum class LISTEN
    {
        RefOnly,
        RefAndDescendents,
    };

    enum class MARK
    {
        Default,
        Check,
        Circle,
        Cross,
        Diamond,
        Square,
        Star,
    };

    enum class MATCH
    {
        Once,
        DataRef,
        Global,
        None,
    };

    enum class MERGEMODE
    {
        ConsumeData,
        MatchTemplate,
    };

    enum class MULTILINE
    {
        _1,
        _0,
    };

    enum class NEXT
    {
        None,
        ContentArea,
        PageArea,
    };

    enum class NULLTEST
    {
        Disabled,
        Error,
        Warning,
    };

    enum class ODDOREVEN
    {
        Any,
        Even,
        Odd,
    };

    enum class OPEN
    {
        UserControl,
        Always,
        MultiSelect,
        OnEntry,
    };

    enum class OPERATION
    {
        Encrypt,
        Decrypt,
    };

    enum class OPERATION2
    {
        Next,
        Back,
        Down,
        First,
        Left,
        Right,
        Up,
    };

    enum class OPERATION1
    {
        Sign,
        Clear,
        Verify,
    };

    enum class ORIENTATION
    {
        Portrait,
        Landscape,
    };

    enum class OVERLINEPERIOD
    {
        All,
        Word,
    };

    enum class OVERLINE
    {
        _0,
        _1,
        _2,
    };

    enum class OVERRIDE
    {
        Disabled,
        Error,
        Ignore,
        Warning,
    };

    enum class PAGEPOSITION
    {
        Any,
        First,
        Last,
        Only,
        Rest,
    };

    enum class PERMISSIONS
    {
        _2,
        _1,
        _3,
    };

    enum class PICKER
    {
        Host,
        None,
    };

    enum class PLACEMENT
    {
        Left,
        Bottom,
        Inline,
        Right,
        Top,
    };

    enum class POSTURE
    {
        Normal,
        Italic,
    };

    enum class PRESENCE
    {
        Visible,
        Hidden,
        Inactive,
        Invisible,
    };

    enum class PREVIOUS
    {
        None,
        ContentArea,
        PageArea,
    };

    enum class PRIORITY
    {
        Custom,
        Caption,
        Name,
        ToolTip,
    };

    enum class RELATION1
    {
        Ordered,
        Choice,
        Unordered,
    };

    enum class RELATION
    {
        OrderedOccurrence,
        DuplexPaginated,
        SimplexPaginated,
    };

    enum class RESTORESTATE
    {
        Manual,
        Auto,
    };

    enum class RUNAT
    {
        Client,
        Both,
        Server,
    };

    enum class SCOPE
    {
        Name,
        None,
    };

    enum class SCRIPTTEST
    {
        Error,
        Disabled,
        Warning,
    };

    enum class SHAPE
    {
        Square,
        Round,
    };

    enum class SIGNATURETYPE
    {
        Filler,
        Author,
    };

    enum class SLOPE
    {
        Backslash,
        Slash,
    };

    enum class STROKE
    {
        Solid,
        DashDot,
        DashDotDot,
        Dashed,
        Dotted,
        Embossed,
        Etched,
        Lowered,
        Raised,
    };

    enum class TARGETTYPE
    {
        Auto,
        ContentArea,
        PageArea,
        PageEven,
        PageOdd,
    };

    enum class TEXTLOCATION
    {
        Below,
        Above,
        AboveEmbedded,
        BelowEmbedded,
        None,
    };

    enum class TRANSFERENCODING1
    {
        Base64,
        None,
        Package,
    };

    enum class TRANSFERENCODING
    {
        None,
        Base64,
        Package,
    };

    enum class TRAYIN
    {
        Auto,
        Delegate,
        PageFront,
    };

    enum class TRAYOUT
    {
        Auto,
        Delegate,
    };

    enum class TYPE4
    {
        PDF1_3,
        PDF1_6,
    };

    enum class TYPE2
    {
        CrossHatch,
        CrossDiagonal,
        DiagonalLeft,
        DiagonalRight,
        Horizontal,
        Vertical,
    };

    enum class TYPE
    {
        Optional,
        Required,
    };

    enum class TYPE3
    {
        ToEdge,
        ToCenter,
    };

    enum class TYPE1
    {
        ToRight,
        ToBottom,
        ToLeft,
        ToTop,
    };

    enum class UNDERLINEPERIOD
    {
        All,
        Word,
    };

    enum class UNDERLINE
    {
        _0,
        _1,
        _2,
    };

    enum class UPSMODE
    {
        UsCarrier,
        InternationalCarrier,
        SecureSymbol,
        StandardSymbol,
    };

    enum class USAGE
    {
        ExportAndImport,
        ExportOnly,
        ImportOnly,
    };

    enum class VALIGN
    {
        Top,
        Bottom,
        Middle,
    };

    enum class VSCROLLPOLICY
    {
        Auto,
        Off,
        On,
    };

    enum class WEIGHT
    {
        Normal,
        Bold,
    };

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<ACCESS>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(ACCESS::Open, "open"),
            std::make_pair(ACCESS::NonInteractive, "nonInteractive"),
            std::make_pair(ACCESS::Protected, "protected"),
            std::make_pair(ACCESS::ReadOnly, "readOnly"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<ACTION>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(ACTION::Include, "include"),
            std::make_pair(ACTION::All, "all"),
            std::make_pair(ACTION::Exclude, "exclude"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<ACTIVITY>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(ACTIVITY::Click, "click"),
            std::make_pair(ACTIVITY::Change, "change"),
            std::make_pair(ACTIVITY::DocClose, "docClose"),
            std::make_pair(ACTIVITY::DocReady, "docReady"),
            std::make_pair(ACTIVITY::Enter, "enter"),
            std::make_pair(ACTIVITY::Exit, "exit"),
            std::make_pair(ACTIVITY::Full, "full"),
            std::make_pair(ACTIVITY::IndexChange, "indexChange"),
            std::make_pair(ACTIVITY::Initialize, "initialize"),
            std::make_pair(ACTIVITY::MouseDown, "mouseDown"),
            std::make_pair(ACTIVITY::MouseEnter, "mouseEnter"),
            std::make_pair(ACTIVITY::MouseExit, "mouseExit"),
            std::make_pair(ACTIVITY::MouseUp, "mouseUp"),
            std::make_pair(ACTIVITY::PostExecute, "postExecute"),
            std::make_pair(ACTIVITY::PostOpen, "postOpen"),
            std::make_pair(ACTIVITY::PostPrint, "postPrint"),
            std::make_pair(ACTIVITY::PostSave, "postSave"),
            std::make_pair(ACTIVITY::PostSign, "postSign"),
            std::make_pair(ACTIVITY::PostSubmit, "postSubmit"),
            std::make_pair(ACTIVITY::PreExecute, "preExecute"),
            std::make_pair(ACTIVITY::PreOpen, "preOpen"),
            std::make_pair(ACTIVITY::PrePrint, "prePrint"),
            std::make_pair(ACTIVITY::PreSave, "preSave"),
            std::make_pair(ACTIVITY::PreSign, "preSign"),
            std::make_pair(ACTIVITY::PreSubmit, "preSubmit"),
            std::make_pair(ACTIVITY::Ready, "ready"),
            std::make_pair(ACTIVITY::ValidationState, "validationState"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<AFTER>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(AFTER::Auto, "auto"),
            std::make_pair(AFTER::ContentArea, "contentArea"),
            std::make_pair(AFTER::PageArea, "pageArea"),
            std::make_pair(AFTER::PageEven, "pageEven"),
            std::make_pair(AFTER::PageOdd, "pageOdd"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<ANCHORTYPE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(ANCHORTYPE::TopLeft, "topLeft"),
            std::make_pair(ANCHORTYPE::BottomCenter, "bottomCenter"),
            std::make_pair(ANCHORTYPE::BottomLeft, "bottomLeft"),
            std::make_pair(ANCHORTYPE::BottomRight, "bottomRight"),
            std::make_pair(ANCHORTYPE::MiddleCenter, "middleCenter"),
            std::make_pair(ANCHORTYPE::MiddleLeft, "middleLeft"),
            std::make_pair(ANCHORTYPE::MiddleRight, "middleRight"),
            std::make_pair(ANCHORTYPE::TopCenter, "topCenter"),
            std::make_pair(ANCHORTYPE::TopRight, "topRight"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<ASPECT>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(ASPECT::Fit, "fit"),
            std::make_pair(ASPECT::Actual, "actual"),
            std::make_pair(ASPECT::Height, "height"),
            std::make_pair(ASPECT::None, "none"),
            std::make_pair(ASPECT::Width, "width"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<BASEPROFILE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(BASEPROFILE::Full, "full"),
            std::make_pair(BASEPROFILE::InteractiveForms, "interactiveForms"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<BEFORE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(BEFORE::Auto, "auto"),
            std::make_pair(BEFORE::ContentArea, "contentArea"),
            std::make_pair(BEFORE::PageArea, "pageArea"),
            std::make_pair(BEFORE::PageEven, "pageEven"),
            std::make_pair(BEFORE::PageOdd, "pageOdd"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<BLANKORNOTBLANK>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(BLANKORNOTBLANK::Any, "any"),
            std::make_pair(BLANKORNOTBLANK::Blank, "blank"),
            std::make_pair(BLANKORNOTBLANK::NotBlank, "notBlank"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<BREAK>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(BREAK::Close, "close"),
            std::make_pair(BREAK::Open, "open"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<CAP>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(CAP::Square, "square"),
            std::make_pair(CAP::Butt, "butt"),
            std::make_pair(CAP::Round, "round"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<CHECKSUM>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(CHECKSUM::None, "none"),
            std::make_pair(CHECKSUM::_1mod10, "1mod10"),
            std::make_pair(CHECKSUM::_1mod10_1mod11, "1mod10_1mod11"),
            std::make_pair(CHECKSUM::_2mod10, "2mod10"),
            std::make_pair(CHECKSUM::Auto, "auto"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<COMMITON>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(COMMITON::Select, "select"),
            std::make_pair(COMMITON::Exit, "exit"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<CREDENTIALSERVERPOLICY>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(CREDENTIALSERVERPOLICY::Optional, "optional"),
            std::make_pair(CREDENTIALSERVERPOLICY::Required, "required"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<DATAPREP>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(DATAPREP::None, "none"),
            std::make_pair(DATAPREP::FlateCompress, "flateCompress"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<DATA>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(DATA::Link, "link"),
            std::make_pair(DATA::Embed, "embed"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<DUPLEXIMPOSITION>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(DUPLEXIMPOSITION::LongEdge, "longEdge"),
            std::make_pair(DUPLEXIMPOSITION::ShortEdge, "shortEdge"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<EXECUTETYPE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(EXECUTETYPE::Import, "import"),
            std::make_pair(EXECUTETYPE::Remerge, "remerge"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<FORMATTEST>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(FORMATTEST::Warning, "warning"),
            std::make_pair(FORMATTEST::Disabled, "disabled"),
            std::make_pair(FORMATTEST::Error, "error"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<FORMAT>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(FORMAT::Xdp, "xdp"),
            std::make_pair(FORMAT::Formdata, "formdata"),
            std::make_pair(FORMAT::Pdf, "pdf"),
            std::make_pair(FORMAT::Urlencoded, "urlencoded"),
            std::make_pair(FORMAT::Xfd, "xfd"),
            std::make_pair(FORMAT::Xml, "xml"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<HALIGN>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(HALIGN::Left, "left"),
            std::make_pair(HALIGN::Center, "center"),
            std::make_pair(HALIGN::Justify, "justify"),
            std::make_pair(HALIGN::JustifyAll, "justifyAll"),
            std::make_pair(HALIGN::Radix, "radix"),
            std::make_pair(HALIGN::Right, "right"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<HSCROLLPOLICY>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(HSCROLLPOLICY::Auto, "auto"),
            std::make_pair(HSCROLLPOLICY::Off, "off"),
            std::make_pair(HSCROLLPOLICY::On, "on"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<HAND>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(HAND::Even, "even"),
            std::make_pair(HAND::Left, "left"),
            std::make_pair(HAND::Right, "right"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<HIGHLIGHT>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(HIGHLIGHT::Inverted, "inverted"),
            std::make_pair(HIGHLIGHT::None, "none"),
            std::make_pair(HIGHLIGHT::Outline, "outline"),
            std::make_pair(HIGHLIGHT::Push, "push"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<INTACT>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(INTACT::None, "none"),
            std::make_pair(INTACT::ContentArea, "contentArea"),
            std::make_pair(INTACT::PageArea, "pageArea"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<JOIN>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(JOIN::Square, "square"),
            std::make_pair(JOIN::Round, "round"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<KERNINGMODE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(KERNINGMODE::None, "none"),
            std::make_pair(KERNINGMODE::Pair, "pair"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<LAYOUT>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(LAYOUT::Position, "position"),
            std::make_pair(LAYOUT::Lr_tb, "lr-tb"),
            std::make_pair(LAYOUT::Rl_row, "rl-row"),
            std::make_pair(LAYOUT::Rl_tb, "rl-tb"),
            std::make_pair(LAYOUT::Row, "row"),
            std::make_pair(LAYOUT::Table, "table"),
            std::make_pair(LAYOUT::Tb, "tb"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<LINETHROUGHPERIOD>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(LINETHROUGHPERIOD::All, "all"),
            std::make_pair(LINETHROUGHPERIOD::Word, "word"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<LINETHROUGH>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(LINETHROUGH::_0, "0"),
            std::make_pair(LINETHROUGH::_1, "1"),
            std::make_pair(LINETHROUGH::_2, "2"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<LISTEN>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(LISTEN::RefOnly, "refOnly"),
            std::make_pair(LISTEN::RefAndDescendents, "refAndDescendents"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<MARK>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(MARK::Default, "default"),
            std::make_pair(MARK::Check, "check"),
            std::make_pair(MARK::Circle, "circle"),
            std::make_pair(MARK::Cross, "cross"),
            std::make_pair(MARK::Diamond, "diamond"),
            std::make_pair(MARK::Square, "square"),
            std::make_pair(MARK::Star, "star"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<MATCH>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(MATCH::Once, "once"),
            std::make_pair(MATCH::DataRef, "dataRef"),
            std::make_pair(MATCH::Global, "global"),
            std::make_pair(MATCH::None, "none"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<MERGEMODE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(MERGEMODE::ConsumeData, "consumeData"),
            std::make_pair(MERGEMODE::MatchTemplate, "matchTemplate"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<MULTILINE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(MULTILINE::_1, "1"),
            std::make_pair(MULTILINE::_0, "0"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<NEXT>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(NEXT::None, "none"),
            std::make_pair(NEXT::ContentArea, "contentArea"),
            std::make_pair(NEXT::PageArea, "pageArea"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<NULLTEST>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(NULLTEST::Disabled, "disabled"),
            std::make_pair(NULLTEST::Error, "error"),
            std::make_pair(NULLTEST::Warning, "warning"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<ODDOREVEN>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(ODDOREVEN::Any, "any"),
            std::make_pair(ODDOREVEN::Even, "even"),
            std::make_pair(ODDOREVEN::Odd, "odd"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<OPEN>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(OPEN::UserControl, "userControl"),
            std::make_pair(OPEN::Always, "always"),
            std::make_pair(OPEN::MultiSelect, "multiSelect"),
            std::make_pair(OPEN::OnEntry, "onEntry"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<OPERATION>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(OPERATION::Encrypt, "encrypt"),
            std::make_pair(OPERATION::Decrypt, "decrypt"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<OPERATION2>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(OPERATION2::Next, "next"),
            std::make_pair(OPERATION2::Back, "back"),
            std::make_pair(OPERATION2::Down, "down"),
            std::make_pair(OPERATION2::First, "first"),
            std::make_pair(OPERATION2::Left, "left"),
            std::make_pair(OPERATION2::Right, "right"),
            std::make_pair(OPERATION2::Up, "up"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<OPERATION1>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(OPERATION1::Sign, "sign"),
            std::make_pair(OPERATION1::Clear, "clear"),
            std::make_pair(OPERATION1::Verify, "verify"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<ORIENTATION>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(ORIENTATION::Portrait, "portrait"),
            std::make_pair(ORIENTATION::Landscape, "landscape"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<OVERLINEPERIOD>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(OVERLINEPERIOD::All, "all"),
            std::make_pair(OVERLINEPERIOD::Word, "word"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<OVERLINE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(OVERLINE::_0, "0"),
            std::make_pair(OVERLINE::_1, "1"),
            std::make_pair(OVERLINE::_2, "2"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<OVERRIDE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(OVERRIDE::Disabled, "disabled"),
            std::make_pair(OVERRIDE::Error, "error"),
            std::make_pair(OVERRIDE::Ignore, "ignore"),
            std::make_pair(OVERRIDE::Warning, "warning"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<PAGEPOSITION>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(PAGEPOSITION::Any, "any"),
            std::make_pair(PAGEPOSITION::First, "first"),
            std::make_pair(PAGEPOSITION::Last, "last"),
            std::make_pair(PAGEPOSITION::Only, "only"),
            std::make_pair(PAGEPOSITION::Rest, "rest"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<PERMISSIONS>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(PERMISSIONS::_2, "2"),
            std::make_pair(PERMISSIONS::_1, "1"),
            std::make_pair(PERMISSIONS::_3, "3"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<PICKER>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(PICKER::Host, "host"),
            std::make_pair(PICKER::None, "none"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<PLACEMENT>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(PLACEMENT::Left, "left"),
            std::make_pair(PLACEMENT::Bottom, "bottom"),
            std::make_pair(PLACEMENT::Inline, "inline"),
            std::make_pair(PLACEMENT::Right, "right"),
            std::make_pair(PLACEMENT::Top, "top"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<POSTURE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(POSTURE::Normal, "normal"),
            std::make_pair(POSTURE::Italic, "italic"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<PRESENCE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(PRESENCE::Visible, "visible"),
            std::make_pair(PRESENCE::Hidden, "hidden"),
            std::make_pair(PRESENCE::Inactive, "inactive"),
            std::make_pair(PRESENCE::Invisible, "invisible"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<PREVIOUS>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(PREVIOUS::None, "none"),
            std::make_pair(PREVIOUS::ContentArea, "contentArea"),
            std::make_pair(PREVIOUS::PageArea, "pageArea"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<PRIORITY>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(PRIORITY::Custom, "custom"),
            std::make_pair(PRIORITY::Caption, "caption"),
            std::make_pair(PRIORITY::Name, "name"),
            std::make_pair(PRIORITY::ToolTip, "toolTip"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<RELATION1>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(RELATION1::Ordered, "ordered"),
            std::make_pair(RELATION1::Choice, "choice"),
            std::make_pair(RELATION1::Unordered, "unordered"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<RELATION>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(RELATION::OrderedOccurrence, "orderedOccurrence"),
            std::make_pair(RELATION::DuplexPaginated, "duplexPaginated"),
            std::make_pair(RELATION::SimplexPaginated, "simplexPaginated"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<RESTORESTATE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(RESTORESTATE::Manual, "manual"),
            std::make_pair(RESTORESTATE::Auto, "auto"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<RUNAT>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(RUNAT::Client, "client"),
            std::make_pair(RUNAT::Both, "both"),
            std::make_pair(RUNAT::Server, "server"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<SCOPE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(SCOPE::Name, "name"),
            std::make_pair(SCOPE::None, "none"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<SCRIPTTEST>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(SCRIPTTEST::Error, "error"),
            std::make_pair(SCRIPTTEST::Disabled, "disabled"),
            std::make_pair(SCRIPTTEST::Warning, "warning"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<SHAPE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(SHAPE::Square, "square"),
            std::make_pair(SHAPE::Round, "round"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<SIGNATURETYPE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(SIGNATURETYPE::Filler, "filler"),
            std::make_pair(SIGNATURETYPE::Author, "author"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<SLOPE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(SLOPE::Backslash, "\\"),
            std::make_pair(SLOPE::Slash, "/"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<STROKE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(STROKE::Solid, "solid"),
            std::make_pair(STROKE::DashDot, "dashDot"),
            std::make_pair(STROKE::DashDotDot, "dashDotDot"),
            std::make_pair(STROKE::Dashed, "dashed"),
            std::make_pair(STROKE::Dotted, "dotted"),
            std::make_pair(STROKE::Embossed, "embossed"),
            std::make_pair(STROKE::Etched, "etched"),
            std::make_pair(STROKE::Lowered, "lowered"),
            std::make_pair(STROKE::Raised, "raised"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<TARGETTYPE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(TARGETTYPE::Auto, "auto"),
            std::make_pair(TARGETTYPE::ContentArea, "contentArea"),
            std::make_pair(TARGETTYPE::PageArea, "pageArea"),
            std::make_pair(TARGETTYPE::PageEven, "pageEven"),
            std::make_pair(TARGETTYPE::PageOdd, "pageOdd"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<TEXTLOCATION>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(TEXTLOCATION::Below, "below"),
            std::make_pair(TEXTLOCATION::Above, "above"),
            std::make_pair(TEXTLOCATION::AboveEmbedded, "aboveEmbedded"),
            std::make_pair(TEXTLOCATION::BelowEmbedded, "belowEmbedded"),
            std::make_pair(TEXTLOCATION::None, "none"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<TRANSFERENCODING1>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(TRANSFERENCODING1::Base64, "base64"),
            std::make_pair(TRANSFERENCODING1::None, "none"),
            std::make_pair(TRANSFERENCODING1::Package, "package"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<TRANSFERENCODING>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(TRANSFERENCODING::None, "none"),
            std::make_pair(TRANSFERENCODING::Base64, "base64"),
            std::make_pair(TRANSFERENCODING::Package, "package"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<TRAYIN>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(TRAYIN::Auto, "auto"),
            std::make_pair(TRAYIN::Delegate, "delegate"),
            std::make_pair(TRAYIN::PageFront, "pageFront"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<TRAYOUT>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(TRAYOUT::Auto, "auto"),
            std::make_pair(TRAYOUT::Delegate, "delegate"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<TYPE4>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(TYPE4::PDF1_3, "PDF1.3"),
            std::make_pair(TYPE4::PDF1_6, "PDF1.6"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<TYPE2>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(TYPE2::CrossHatch, "crossHatch"),
            std::make_pair(TYPE2::CrossDiagonal, "crossDiagonal"),
            std::make_pair(TYPE2::DiagonalLeft, "diagonalLeft"),
            std::make_pair(TYPE2::DiagonalRight, "diagonalRight"),
            std::make_pair(TYPE2::Horizontal, "horizontal"),
            std::make_pair(TYPE2::Vertical, "vertical"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<TYPE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(TYPE::Optional, "optional"),
            std::make_pair(TYPE::Required, "required"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<TYPE3>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(TYPE3::ToEdge, "toEdge"),
            std::make_pair(TYPE3::ToCenter, "toCenter"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<TYPE1>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(TYPE1::ToRight, "toRight"),
            std::make_pair(TYPE1::ToBottom, "toBottom"),
            std::make_pair(TYPE1::ToLeft, "toLeft"),
            std::make_pair(TYPE1::ToTop, "toTop"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<UNDERLINEPERIOD>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(UNDERLINEPERIOD::All, "all"),
            std::make_pair(UNDERLINEPERIOD::Word, "word"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<UNDERLINE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(UNDERLINE::_0, "0"),
            std::make_pair(UNDERLINE::_1, "1"),
            std::make_pair(UNDERLINE::_2, "2"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<UPSMODE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(UPSMODE::UsCarrier, "usCarrier"),
            std::make_pair(UPSMODE::InternationalCarrier, "internationalCarrier"),
            std::make_pair(UPSMODE::SecureSymbol, "secureSymbol"),
            std::make_pair(UPSMODE::StandardSymbol, "standardSymbol"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<USAGE>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(USAGE::ExportAndImport, "exportAndImport"),
            std::make_pair(USAGE::ExportOnly, "exportOnly"),
            std::make_pair(USAGE::ImportOnly, "importOnly"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<VALIGN>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(VALIGN::Top, "top"),
            std::make_pair(VALIGN::Bottom, "bottom"),
            std::make_pair(VALIGN::Middle, "middle"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<VSCROLLPOLICY>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(VSCROLLPOLICY::Auto, "auto"),
            std::make_pair(VSCROLLPOLICY::Off, "off"),
            std::make_pair(VSCROLLPOLICY::On, "on"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

    static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<WEIGHT>& attribute, QString defaultValue)
    {
        constexpr std::array enumValues = {
            std::make_pair(WEIGHT::Normal, "normal"),
            std::make_pair(WEIGHT::Bold, "bold"),
        };
        parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);
    }

};

class XFA_appearanceFilter : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const TYPE* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_appearanceFilter> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<TYPE> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_appearanceFilter> XFA_appearanceFilter::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_appearanceFilter myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "type", myClass.m_type, "optional");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_arc : public XFA_BaseNode
{
public:

    const bool* getCircular() const {  return m_circular.getValue(); }
    const HAND* getHand() const {  return m_hand.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const PDFReal* getStartAngle() const {  return m_startAngle.getValue(); }
    const PDFReal* getSweepAngle() const {  return m_sweepAngle.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_edge* getEdge() const {  return m_edge.getValue(); }
    const XFA_fill* getFill() const {  return m_fill.getValue(); }

    static std::optional<XFA_arc> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<bool> m_circular;
    XFA_Attribute<HAND> m_hand;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<PDFReal> m_startAngle;
    XFA_Attribute<PDFReal> m_sweepAngle;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_edge> m_edge;
    XFA_Node<XFA_fill> m_fill;
};

std::optional<XFA_arc> XFA_arc::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_arc myClass;

    // load attributes
    parseAttribute(element, "circular", myClass.m_circular, "0");
    parseAttribute(element, "hand", myClass.m_hand, "even");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "startAngle", myClass.m_startAngle, "0");
    parseAttribute(element, "sweepAngle", myClass.m_sweepAngle, "360");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "edge", myClass.m_edge);
    parseItem(element, "fill", myClass.m_fill);
    return myClass;
}


class XFA_area : public XFA_BaseNode
{
public:

    const PDFInteger* getColSpan() const {  return m_colSpan.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getRelevant() const {  return m_relevant.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }
    const XFA_Measurement* getX() const {  return m_x.getValue(); }
    const XFA_Measurement* getY() const {  return m_y.getValue(); }

    const XFA_desc* getDesc() const {  return m_desc.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const std::vector<XFA_Node<XFA_area>>& getArea() const {  return m_area; }
    const std::vector<XFA_Node<XFA_draw>>& getDraw() const {  return m_draw; }
    const std::vector<XFA_Node<XFA_exObject>>& getExObject() const {  return m_exObject; }
    const std::vector<XFA_Node<XFA_exclGroup>>& getExclGroup() const {  return m_exclGroup; }
    const std::vector<XFA_Node<XFA_field>>& getField() const {  return m_field; }
    const std::vector<XFA_Node<XFA_subform>>& getSubform() const {  return m_subform; }
    const std::vector<XFA_Node<XFA_subformSet>>& getSubformSet() const {  return m_subformSet; }

    static std::optional<XFA_area> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<PDFInteger> m_colSpan;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_relevant;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;
    XFA_Attribute<XFA_Measurement> m_x;
    XFA_Attribute<XFA_Measurement> m_y;

    /* subnodes */
    XFA_Node<XFA_desc> m_desc;
    XFA_Node<XFA_extras> m_extras;
    std::vector<XFA_Node<XFA_area>> m_area;
    std::vector<XFA_Node<XFA_draw>> m_draw;
    std::vector<XFA_Node<XFA_exObject>> m_exObject;
    std::vector<XFA_Node<XFA_exclGroup>> m_exclGroup;
    std::vector<XFA_Node<XFA_field>> m_field;
    std::vector<XFA_Node<XFA_subform>> m_subform;
    std::vector<XFA_Node<XFA_subformSet>> m_subformSet;
};

std::optional<XFA_area> XFA_area::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_area myClass;

    // load attributes
    parseAttribute(element, "colSpan", myClass.m_colSpan, "1");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "relevant", myClass.m_relevant, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");
    parseAttribute(element, "x", myClass.m_x, "0in");
    parseAttribute(element, "y", myClass.m_y, "0in");

    // load items
    parseItem(element, "desc", myClass.m_desc);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "area", myClass.m_area);
    parseItem(element, "draw", myClass.m_draw);
    parseItem(element, "exObject", myClass.m_exObject);
    parseItem(element, "exclGroup", myClass.m_exclGroup);
    parseItem(element, "field", myClass.m_field);
    parseItem(element, "subform", myClass.m_subform);
    parseItem(element, "subformSet", myClass.m_subformSet);
    return myClass;
}


class XFA_assist : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getRole() const {  return m_role.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_speak* getSpeak() const {  return m_speak.getValue(); }
    const XFA_toolTip* getToolTip() const {  return m_toolTip.getValue(); }

    static std::optional<XFA_assist> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_role;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_speak> m_speak;
    XFA_Node<XFA_toolTip> m_toolTip;
};

std::optional<XFA_assist> XFA_assist::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_assist myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "role", myClass.m_role, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "speak", myClass.m_speak);
    parseItem(element, "toolTip", myClass.m_toolTip);
    return myClass;
}


class XFA_barcode : public XFA_BaseNode
{
public:

    const QString* getCharEncoding() const {  return m_charEncoding.getValue(); }
    const CHECKSUM* getChecksum() const {  return m_checksum.getValue(); }
    const QString* getDataColumnCount() const {  return m_dataColumnCount.getValue(); }
    const QString* getDataLength() const {  return m_dataLength.getValue(); }
    const DATAPREP* getDataPrep() const {  return m_dataPrep.getValue(); }
    const QString* getDataRowCount() const {  return m_dataRowCount.getValue(); }
    const QString* getEndChar() const {  return m_endChar.getValue(); }
    const QString* getErrorCorrectionLevel() const {  return m_errorCorrectionLevel.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const XFA_Measurement* getModuleHeight() const {  return m_moduleHeight.getValue(); }
    const XFA_Measurement* getModuleWidth() const {  return m_moduleWidth.getValue(); }
    const bool* getPrintCheckDigit() const {  return m_printCheckDigit.getValue(); }
    const QString* getRowColumnRatio() const {  return m_rowColumnRatio.getValue(); }
    const QString* getStartChar() const {  return m_startChar.getValue(); }
    const TEXTLOCATION* getTextLocation() const {  return m_textLocation.getValue(); }
    const bool* getTruncate() const {  return m_truncate.getValue(); }
    const QString* getType() const {  return m_type.getValue(); }
    const UPSMODE* getUpsMode() const {  return m_upsMode.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }
    const QString* getWideNarrowRatio() const {  return m_wideNarrowRatio.getValue(); }

    const XFA_encrypt* getEncrypt() const {  return m_encrypt.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }

    static std::optional<XFA_barcode> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_charEncoding;
    XFA_Attribute<CHECKSUM> m_checksum;
    XFA_Attribute<QString> m_dataColumnCount;
    XFA_Attribute<QString> m_dataLength;
    XFA_Attribute<DATAPREP> m_dataPrep;
    XFA_Attribute<QString> m_dataRowCount;
    XFA_Attribute<QString> m_endChar;
    XFA_Attribute<QString> m_errorCorrectionLevel;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<XFA_Measurement> m_moduleHeight;
    XFA_Attribute<XFA_Measurement> m_moduleWidth;
    XFA_Attribute<bool> m_printCheckDigit;
    XFA_Attribute<QString> m_rowColumnRatio;
    XFA_Attribute<QString> m_startChar;
    XFA_Attribute<TEXTLOCATION> m_textLocation;
    XFA_Attribute<bool> m_truncate;
    XFA_Attribute<QString> m_type;
    XFA_Attribute<UPSMODE> m_upsMode;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;
    XFA_Attribute<QString> m_wideNarrowRatio;

    /* subnodes */
    XFA_Node<XFA_encrypt> m_encrypt;
    XFA_Node<XFA_extras> m_extras;
};

std::optional<XFA_barcode> XFA_barcode::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_barcode myClass;

    // load attributes
    parseAttribute(element, "charEncoding", myClass.m_charEncoding, "");
    parseAttribute(element, "checksum", myClass.m_checksum, "none");
    parseAttribute(element, "dataColumnCount", myClass.m_dataColumnCount, "");
    parseAttribute(element, "dataLength", myClass.m_dataLength, "");
    parseAttribute(element, "dataPrep", myClass.m_dataPrep, "none");
    parseAttribute(element, "dataRowCount", myClass.m_dataRowCount, "");
    parseAttribute(element, "endChar", myClass.m_endChar, "");
    parseAttribute(element, "errorCorrectionLevel", myClass.m_errorCorrectionLevel, "");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "moduleHeight", myClass.m_moduleHeight, "5mm");
    parseAttribute(element, "moduleWidth", myClass.m_moduleWidth, "0.25mm");
    parseAttribute(element, "printCheckDigit", myClass.m_printCheckDigit, "0");
    parseAttribute(element, "rowColumnRatio", myClass.m_rowColumnRatio, "");
    parseAttribute(element, "startChar", myClass.m_startChar, "");
    parseAttribute(element, "textLocation", myClass.m_textLocation, "below");
    parseAttribute(element, "truncate", myClass.m_truncate, "");
    parseAttribute(element, "type", myClass.m_type, "");
    parseAttribute(element, "upsMode", myClass.m_upsMode, "usCarrier");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");
    parseAttribute(element, "wideNarrowRatio", myClass.m_wideNarrowRatio, "");

    // load items
    parseItem(element, "encrypt", myClass.m_encrypt);
    parseItem(element, "extras", myClass.m_extras);
    return myClass;
}


class XFA_bind : public XFA_BaseNode
{
public:

    const MATCH* getMatch() const {  return m_match.getValue(); }
    const QString* getRef() const {  return m_ref.getValue(); }

    const XFA_picture* getPicture() const {  return m_picture.getValue(); }

    static std::optional<XFA_bind> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<MATCH> m_match;
    XFA_Attribute<QString> m_ref;

    /* subnodes */
    XFA_Node<XFA_picture> m_picture;
};

std::optional<XFA_bind> XFA_bind::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_bind myClass;

    // load attributes
    parseAttribute(element, "match", myClass.m_match, "once");
    parseAttribute(element, "ref", myClass.m_ref, "");

    // load items
    parseItem(element, "picture", myClass.m_picture);
    return myClass;
}


class XFA_bindItems : public XFA_BaseNode
{
public:

    const QString* getConnection() const {  return m_connection.getValue(); }
    const QString* getLabelRef() const {  return m_labelRef.getValue(); }
    const QString* getRef() const {  return m_ref.getValue(); }
    const QString* getValueRef() const {  return m_valueRef.getValue(); }


    static std::optional<XFA_bindItems> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_connection;
    XFA_Attribute<QString> m_labelRef;
    XFA_Attribute<QString> m_ref;
    XFA_Attribute<QString> m_valueRef;

    /* subnodes */
};

std::optional<XFA_bindItems> XFA_bindItems::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_bindItems myClass;

    // load attributes
    parseAttribute(element, "connection", myClass.m_connection, "");
    parseAttribute(element, "labelRef", myClass.m_labelRef, "");
    parseAttribute(element, "ref", myClass.m_ref, "");
    parseAttribute(element, "valueRef", myClass.m_valueRef, "");

    // load items
    return myClass;
}


class XFA_bookend : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getLeader() const {  return m_leader.getValue(); }
    const QString* getTrailer() const {  return m_trailer.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    static std::optional<XFA_bookend> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_leader;
    XFA_Attribute<QString> m_trailer;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
};

std::optional<XFA_bookend> XFA_bookend::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_bookend myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "leader", myClass.m_leader, "");
    parseAttribute(element, "trailer", myClass.m_trailer, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_boolean : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_boolean> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_boolean> XFA_boolean::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_boolean myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_border : public XFA_BaseNode
{
public:

    const BREAK* getBreak() const {  return m_break.getValue(); }
    const HAND* getHand() const {  return m_hand.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const PRESENCE* getPresence() const {  return m_presence.getValue(); }
    const QString* getRelevant() const {  return m_relevant.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const std::vector<XFA_Node<XFA_corner>>& getCorner() const {  return m_corner; }
    const std::vector<XFA_Node<XFA_edge>>& getEdge() const {  return m_edge; }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_fill* getFill() const {  return m_fill.getValue(); }
    const XFA_margin* getMargin() const {  return m_margin.getValue(); }

    static std::optional<XFA_border> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<BREAK> m_break;
    XFA_Attribute<HAND> m_hand;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<PRESENCE> m_presence;
    XFA_Attribute<QString> m_relevant;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    std::vector<XFA_Node<XFA_corner>> m_corner;
    std::vector<XFA_Node<XFA_edge>> m_edge;
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_fill> m_fill;
    XFA_Node<XFA_margin> m_margin;
};

std::optional<XFA_border> XFA_border::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_border myClass;

    // load attributes
    parseAttribute(element, "break", myClass.m_break, "close");
    parseAttribute(element, "hand", myClass.m_hand, "even");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "presence", myClass.m_presence, "visible");
    parseAttribute(element, "relevant", myClass.m_relevant, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "corner", myClass.m_corner);
    parseItem(element, "edge", myClass.m_edge);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "fill", myClass.m_fill);
    parseItem(element, "margin", myClass.m_margin);
    return myClass;
}


class XFA_break : public XFA_BaseNode
{
public:

    const AFTER* getAfter() const {  return m_after.getValue(); }
    const QString* getAfterTarget() const {  return m_afterTarget.getValue(); }
    const BEFORE* getBefore() const {  return m_before.getValue(); }
    const QString* getBeforeTarget() const {  return m_beforeTarget.getValue(); }
    const QString* getBookendLeader() const {  return m_bookendLeader.getValue(); }
    const QString* getBookendTrailer() const {  return m_bookendTrailer.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getOverflowLeader() const {  return m_overflowLeader.getValue(); }
    const QString* getOverflowTarget() const {  return m_overflowTarget.getValue(); }
    const QString* getOverflowTrailer() const {  return m_overflowTrailer.getValue(); }
    const bool* getStartNew() const {  return m_startNew.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }

    static std::optional<XFA_break> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<AFTER> m_after;
    XFA_Attribute<QString> m_afterTarget;
    XFA_Attribute<BEFORE> m_before;
    XFA_Attribute<QString> m_beforeTarget;
    XFA_Attribute<QString> m_bookendLeader;
    XFA_Attribute<QString> m_bookendTrailer;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_overflowLeader;
    XFA_Attribute<QString> m_overflowTarget;
    XFA_Attribute<QString> m_overflowTrailer;
    XFA_Attribute<bool> m_startNew;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
};

std::optional<XFA_break> XFA_break::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_break myClass;

    // load attributes
    parseAttribute(element, "after", myClass.m_after, "auto");
    parseAttribute(element, "afterTarget", myClass.m_afterTarget, "");
    parseAttribute(element, "before", myClass.m_before, "auto");
    parseAttribute(element, "beforeTarget", myClass.m_beforeTarget, "");
    parseAttribute(element, "bookendLeader", myClass.m_bookendLeader, "");
    parseAttribute(element, "bookendTrailer", myClass.m_bookendTrailer, "");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "overflowLeader", myClass.m_overflowLeader, "");
    parseAttribute(element, "overflowTarget", myClass.m_overflowTarget, "");
    parseAttribute(element, "overflowTrailer", myClass.m_overflowTrailer, "");
    parseAttribute(element, "startNew", myClass.m_startNew, "0");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    return myClass;
}


class XFA_breakAfter : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getLeader() const {  return m_leader.getValue(); }
    const bool* getStartNew() const {  return m_startNew.getValue(); }
    const QString* getTarget() const {  return m_target.getValue(); }
    const TARGETTYPE* getTargetType() const {  return m_targetType.getValue(); }
    const QString* getTrailer() const {  return m_trailer.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_script* getScript() const {  return m_script.getValue(); }

    static std::optional<XFA_breakAfter> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_leader;
    XFA_Attribute<bool> m_startNew;
    XFA_Attribute<QString> m_target;
    XFA_Attribute<TARGETTYPE> m_targetType;
    XFA_Attribute<QString> m_trailer;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_script> m_script;
};

std::optional<XFA_breakAfter> XFA_breakAfter::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_breakAfter myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "leader", myClass.m_leader, "");
    parseAttribute(element, "startNew", myClass.m_startNew, "0");
    parseAttribute(element, "target", myClass.m_target, "");
    parseAttribute(element, "targetType", myClass.m_targetType, "auto");
    parseAttribute(element, "trailer", myClass.m_trailer, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "script", myClass.m_script);
    return myClass;
}


class XFA_breakBefore : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getLeader() const {  return m_leader.getValue(); }
    const bool* getStartNew() const {  return m_startNew.getValue(); }
    const QString* getTarget() const {  return m_target.getValue(); }
    const TARGETTYPE* getTargetType() const {  return m_targetType.getValue(); }
    const QString* getTrailer() const {  return m_trailer.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_script* getScript() const {  return m_script.getValue(); }

    static std::optional<XFA_breakBefore> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_leader;
    XFA_Attribute<bool> m_startNew;
    XFA_Attribute<QString> m_target;
    XFA_Attribute<TARGETTYPE> m_targetType;
    XFA_Attribute<QString> m_trailer;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_script> m_script;
};

std::optional<XFA_breakBefore> XFA_breakBefore::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_breakBefore myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "leader", myClass.m_leader, "");
    parseAttribute(element, "startNew", myClass.m_startNew, "0");
    parseAttribute(element, "target", myClass.m_target, "");
    parseAttribute(element, "targetType", myClass.m_targetType, "auto");
    parseAttribute(element, "trailer", myClass.m_trailer, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "script", myClass.m_script);
    return myClass;
}


class XFA_button : public XFA_BaseNode
{
public:

    const HIGHLIGHT* getHighlight() const {  return m_highlight.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }

    static std::optional<XFA_button> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<HIGHLIGHT> m_highlight;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
};

std::optional<XFA_button> XFA_button::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_button myClass;

    // load attributes
    parseAttribute(element, "highlight", myClass.m_highlight, "inverted");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    return myClass;
}


class XFA_calculate : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const OVERRIDE* getOverride() const {  return m_override.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_message* getMessage() const {  return m_message.getValue(); }
    const XFA_script* getScript() const {  return m_script.getValue(); }

    static std::optional<XFA_calculate> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<OVERRIDE> m_override;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_message> m_message;
    XFA_Node<XFA_script> m_script;
};

std::optional<XFA_calculate> XFA_calculate::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_calculate myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "override", myClass.m_override, "disabled");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "message", myClass.m_message);
    parseItem(element, "script", myClass.m_script);
    return myClass;
}


class XFA_caption : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const PLACEMENT* getPlacement() const {  return m_placement.getValue(); }
    const PRESENCE* getPresence() const {  return m_presence.getValue(); }
    const XFA_Measurement* getReserve() const {  return m_reserve.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_font* getFont() const {  return m_font.getValue(); }
    const XFA_margin* getMargin() const {  return m_margin.getValue(); }
    const XFA_para* getPara() const {  return m_para.getValue(); }
    const XFA_value* getValue() const {  return m_value.getValue(); }

    static std::optional<XFA_caption> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<PLACEMENT> m_placement;
    XFA_Attribute<PRESENCE> m_presence;
    XFA_Attribute<XFA_Measurement> m_reserve;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_font> m_font;
    XFA_Node<XFA_margin> m_margin;
    XFA_Node<XFA_para> m_para;
    XFA_Node<XFA_value> m_value;
};

std::optional<XFA_caption> XFA_caption::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_caption myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "placement", myClass.m_placement, "left");
    parseAttribute(element, "presence", myClass.m_presence, "visible");
    parseAttribute(element, "reserve", myClass.m_reserve, "-1");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "font", myClass.m_font);
    parseItem(element, "margin", myClass.m_margin);
    parseItem(element, "para", myClass.m_para);
    parseItem(element, "value", myClass.m_value);
    return myClass;
}


class XFA_certificate : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_certificate> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_certificate> XFA_certificate::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_certificate myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_certificates : public XFA_BaseNode
{
public:

    const CREDENTIALSERVERPOLICY* getCredentialServerPolicy() const {  return m_credentialServerPolicy.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUrl() const {  return m_url.getValue(); }
    const QString* getUrlPolicy() const {  return m_urlPolicy.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_encryption* getEncryption() const {  return m_encryption.getValue(); }
    const XFA_issuers* getIssuers() const {  return m_issuers.getValue(); }
    const XFA_keyUsage* getKeyUsage() const {  return m_keyUsage.getValue(); }
    const XFA_oids* getOids() const {  return m_oids.getValue(); }
    const XFA_signing* getSigning() const {  return m_signing.getValue(); }
    const XFA_subjectDNs* getSubjectDNs() const {  return m_subjectDNs.getValue(); }

    static std::optional<XFA_certificates> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<CREDENTIALSERVERPOLICY> m_credentialServerPolicy;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_url;
    XFA_Attribute<QString> m_urlPolicy;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_encryption> m_encryption;
    XFA_Node<XFA_issuers> m_issuers;
    XFA_Node<XFA_keyUsage> m_keyUsage;
    XFA_Node<XFA_oids> m_oids;
    XFA_Node<XFA_signing> m_signing;
    XFA_Node<XFA_subjectDNs> m_subjectDNs;
};

std::optional<XFA_certificates> XFA_certificates::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_certificates myClass;

    // load attributes
    parseAttribute(element, "credentialServerPolicy", myClass.m_credentialServerPolicy, "optional");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "url", myClass.m_url, "");
    parseAttribute(element, "urlPolicy", myClass.m_urlPolicy, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "encryption", myClass.m_encryption);
    parseItem(element, "issuers", myClass.m_issuers);
    parseItem(element, "keyUsage", myClass.m_keyUsage);
    parseItem(element, "oids", myClass.m_oids);
    parseItem(element, "signing", myClass.m_signing);
    parseItem(element, "subjectDNs", myClass.m_subjectDNs);
    return myClass;
}


class XFA_checkButton : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const MARK* getMark() const {  return m_mark.getValue(); }
    const SHAPE* getShape() const {  return m_shape.getValue(); }
    const XFA_Measurement* getSize() const {  return m_size.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_border* getBorder() const {  return m_border.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_margin* getMargin() const {  return m_margin.getValue(); }

    static std::optional<XFA_checkButton> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<MARK> m_mark;
    XFA_Attribute<SHAPE> m_shape;
    XFA_Attribute<XFA_Measurement> m_size;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_border> m_border;
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_margin> m_margin;
};

std::optional<XFA_checkButton> XFA_checkButton::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_checkButton myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "mark", myClass.m_mark, "default");
    parseAttribute(element, "shape", myClass.m_shape, "square");
    parseAttribute(element, "size", myClass.m_size, "10pt");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "border", myClass.m_border);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "margin", myClass.m_margin);
    return myClass;
}


class XFA_choiceList : public XFA_BaseNode
{
public:

    const COMMITON* getCommitOn() const {  return m_commitOn.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const OPEN* getOpen() const {  return m_open.getValue(); }
    const bool* getTextEntry() const {  return m_textEntry.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_border* getBorder() const {  return m_border.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_margin* getMargin() const {  return m_margin.getValue(); }

    static std::optional<XFA_choiceList> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<COMMITON> m_commitOn;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<OPEN> m_open;
    XFA_Attribute<bool> m_textEntry;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_border> m_border;
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_margin> m_margin;
};

std::optional<XFA_choiceList> XFA_choiceList::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_choiceList myClass;

    // load attributes
    parseAttribute(element, "commitOn", myClass.m_commitOn, "select");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "open", myClass.m_open, "userControl");
    parseAttribute(element, "textEntry", myClass.m_textEntry, "0");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "border", myClass.m_border);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "margin", myClass.m_margin);
    return myClass;
}


class XFA_color : public XFA_BaseNode
{
public:

    const QString* getCSpace() const {  return m_cSpace.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }
    const QString* getValue() const {  return m_value.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }

    static std::optional<XFA_color> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_cSpace;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;
    XFA_Attribute<QString> m_value;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
};

std::optional<XFA_color> XFA_color::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_color myClass;

    // load attributes
    parseAttribute(element, "cSpace", myClass.m_cSpace, "");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");
    parseAttribute(element, "value", myClass.m_value, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    return myClass;
}


class XFA_comb : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const PDFInteger* getNumberOfCells() const {  return m_numberOfCells.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    static std::optional<XFA_comb> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<PDFInteger> m_numberOfCells;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
};

std::optional<XFA_comb> XFA_comb::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_comb myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "numberOfCells", myClass.m_numberOfCells, "0");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_connect : public XFA_BaseNode
{
public:

    const QString* getConnection() const {  return m_connection.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getRef() const {  return m_ref.getValue(); }
    const USAGE* getUsage() const {  return m_usage.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_picture* getPicture() const {  return m_picture.getValue(); }

    static std::optional<XFA_connect> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_connection;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_ref;
    XFA_Attribute<USAGE> m_usage;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_picture> m_picture;
};

std::optional<XFA_connect> XFA_connect::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_connect myClass;

    // load attributes
    parseAttribute(element, "connection", myClass.m_connection, "");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "ref", myClass.m_ref, "");
    parseAttribute(element, "usage", myClass.m_usage, "exportAndImport");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "picture", myClass.m_picture);
    return myClass;
}


class XFA_contentArea : public XFA_BaseNode
{
public:

    const XFA_Measurement* getH() const {  return m_h.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getRelevant() const {  return m_relevant.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }
    const XFA_Measurement* getW() const {  return m_w.getValue(); }
    const XFA_Measurement* getX() const {  return m_x.getValue(); }
    const XFA_Measurement* getY() const {  return m_y.getValue(); }

    const XFA_desc* getDesc() const {  return m_desc.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }

    static std::optional<XFA_contentArea> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<XFA_Measurement> m_h;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_relevant;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;
    XFA_Attribute<XFA_Measurement> m_w;
    XFA_Attribute<XFA_Measurement> m_x;
    XFA_Attribute<XFA_Measurement> m_y;

    /* subnodes */
    XFA_Node<XFA_desc> m_desc;
    XFA_Node<XFA_extras> m_extras;
};

std::optional<XFA_contentArea> XFA_contentArea::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_contentArea myClass;

    // load attributes
    parseAttribute(element, "h", myClass.m_h, "0in");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "relevant", myClass.m_relevant, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");
    parseAttribute(element, "w", myClass.m_w, "0in");
    parseAttribute(element, "x", myClass.m_x, "0in");
    parseAttribute(element, "y", myClass.m_y, "0in");

    // load items
    parseItem(element, "desc", myClass.m_desc);
    parseItem(element, "extras", myClass.m_extras);
    return myClass;
}


class XFA_corner : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const bool* getInverted() const {  return m_inverted.getValue(); }
    const JOIN* getJoin() const {  return m_join.getValue(); }
    const PRESENCE* getPresence() const {  return m_presence.getValue(); }
    const XFA_Measurement* getRadius() const {  return m_radius.getValue(); }
    const STROKE* getStroke() const {  return m_stroke.getValue(); }
    const XFA_Measurement* getThickness() const {  return m_thickness.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_color* getColor() const {  return m_color.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }

    static std::optional<XFA_corner> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<bool> m_inverted;
    XFA_Attribute<JOIN> m_join;
    XFA_Attribute<PRESENCE> m_presence;
    XFA_Attribute<XFA_Measurement> m_radius;
    XFA_Attribute<STROKE> m_stroke;
    XFA_Attribute<XFA_Measurement> m_thickness;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_color> m_color;
    XFA_Node<XFA_extras> m_extras;
};

std::optional<XFA_corner> XFA_corner::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_corner myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "inverted", myClass.m_inverted, "0");
    parseAttribute(element, "join", myClass.m_join, "square");
    parseAttribute(element, "presence", myClass.m_presence, "visible");
    parseAttribute(element, "radius", myClass.m_radius, "0in");
    parseAttribute(element, "stroke", myClass.m_stroke, "solid");
    parseAttribute(element, "thickness", myClass.m_thickness, "0.pt");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "color", myClass.m_color);
    parseItem(element, "extras", myClass.m_extras);
    return myClass;
}


class XFA_date : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_date> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_date> XFA_date::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_date myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_dateTime : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_dateTime> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_dateTime> XFA_dateTime::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_dateTime myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_dateTimeEdit : public XFA_BaseNode
{
public:

    const HSCROLLPOLICY* getHScrollPolicy() const {  return m_hScrollPolicy.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const PICKER* getPicker() const {  return m_picker.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_border* getBorder() const {  return m_border.getValue(); }
    const XFA_comb* getComb() const {  return m_comb.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_margin* getMargin() const {  return m_margin.getValue(); }

    static std::optional<XFA_dateTimeEdit> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<HSCROLLPOLICY> m_hScrollPolicy;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<PICKER> m_picker;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_border> m_border;
    XFA_Node<XFA_comb> m_comb;
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_margin> m_margin;
};

std::optional<XFA_dateTimeEdit> XFA_dateTimeEdit::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_dateTimeEdit myClass;

    // load attributes
    parseAttribute(element, "hScrollPolicy", myClass.m_hScrollPolicy, "auto");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "picker", myClass.m_picker, "host");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "border", myClass.m_border);
    parseItem(element, "comb", myClass.m_comb);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "margin", myClass.m_margin);
    return myClass;
}


class XFA_decimal : public XFA_BaseNode
{
public:

    const PDFInteger* getFracDigits() const {  return m_fracDigits.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const PDFInteger* getLeadDigits() const {  return m_leadDigits.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_decimal> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<PDFInteger> m_fracDigits;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<PDFInteger> m_leadDigits;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_decimal> XFA_decimal::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_decimal myClass;

    // load attributes
    parseAttribute(element, "fracDigits", myClass.m_fracDigits, "2");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "leadDigits", myClass.m_leadDigits, "-1");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_defaultUi : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }

    static std::optional<XFA_defaultUi> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
};

std::optional<XFA_defaultUi> XFA_defaultUi::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_defaultUi myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    return myClass;
}


class XFA_desc : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const std::vector<XFA_Node<XFA_boolean>>& getBoolean() const {  return m_boolean; }
    const std::vector<XFA_Node<XFA_date>>& getDate() const {  return m_date; }
    const std::vector<XFA_Node<XFA_dateTime>>& getDateTime() const {  return m_dateTime; }
    const std::vector<XFA_Node<XFA_decimal>>& getDecimal() const {  return m_decimal; }
    const std::vector<XFA_Node<XFA_exData>>& getExData() const {  return m_exData; }
    const std::vector<XFA_Node<XFA_float>>& getFloat() const {  return m_float; }
    const std::vector<XFA_Node<XFA_image>>& getImage() const {  return m_image; }
    const std::vector<XFA_Node<XFA_integer>>& getInteger() const {  return m_integer; }
    const std::vector<XFA_Node<XFA_text>>& getText() const {  return m_text; }
    const std::vector<XFA_Node<XFA_time>>& getTime() const {  return m_time; }

    static std::optional<XFA_desc> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    std::vector<XFA_Node<XFA_boolean>> m_boolean;
    std::vector<XFA_Node<XFA_date>> m_date;
    std::vector<XFA_Node<XFA_dateTime>> m_dateTime;
    std::vector<XFA_Node<XFA_decimal>> m_decimal;
    std::vector<XFA_Node<XFA_exData>> m_exData;
    std::vector<XFA_Node<XFA_float>> m_float;
    std::vector<XFA_Node<XFA_image>> m_image;
    std::vector<XFA_Node<XFA_integer>> m_integer;
    std::vector<XFA_Node<XFA_text>> m_text;
    std::vector<XFA_Node<XFA_time>> m_time;
};

std::optional<XFA_desc> XFA_desc::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_desc myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "boolean", myClass.m_boolean);
    parseItem(element, "date", myClass.m_date);
    parseItem(element, "dateTime", myClass.m_dateTime);
    parseItem(element, "decimal", myClass.m_decimal);
    parseItem(element, "exData", myClass.m_exData);
    parseItem(element, "float", myClass.m_float);
    parseItem(element, "image", myClass.m_image);
    parseItem(element, "integer", myClass.m_integer);
    parseItem(element, "text", myClass.m_text);
    parseItem(element, "time", myClass.m_time);
    return myClass;
}


class XFA_digestMethod : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_digestMethod> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_digestMethod> XFA_digestMethod::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_digestMethod myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_digestMethods : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const TYPE* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const std::vector<XFA_Node<XFA_digestMethod>>& getDigestMethod() const {  return m_digestMethod; }

    static std::optional<XFA_digestMethods> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<TYPE> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    std::vector<XFA_Node<XFA_digestMethod>> m_digestMethod;
};

std::optional<XFA_digestMethods> XFA_digestMethods::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_digestMethods myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "type", myClass.m_type, "optional");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "digestMethod", myClass.m_digestMethod);
    return myClass;
}


class XFA_draw : public XFA_BaseNode
{
public:

    const ANCHORTYPE* getAnchorType() const {  return m_anchorType.getValue(); }
    const PDFInteger* getColSpan() const {  return m_colSpan.getValue(); }
    const XFA_Measurement* getH() const {  return m_h.getValue(); }
    const HALIGN* getHAlign() const {  return m_hAlign.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getLocale() const {  return m_locale.getValue(); }
    const XFA_Measurement* getMaxH() const {  return m_maxH.getValue(); }
    const XFA_Measurement* getMaxW() const {  return m_maxW.getValue(); }
    const XFA_Measurement* getMinH() const {  return m_minH.getValue(); }
    const XFA_Measurement* getMinW() const {  return m_minW.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const PRESENCE* getPresence() const {  return m_presence.getValue(); }
    const QString* getRelevant() const {  return m_relevant.getValue(); }
    const PDFReal* getRotate() const {  return m_rotate.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }
    const XFA_Measurement* getW() const {  return m_w.getValue(); }
    const XFA_Measurement* getX() const {  return m_x.getValue(); }
    const XFA_Measurement* getY() const {  return m_y.getValue(); }

    const XFA_assist* getAssist() const {  return m_assist.getValue(); }
    const XFA_border* getBorder() const {  return m_border.getValue(); }
    const XFA_caption* getCaption() const {  return m_caption.getValue(); }
    const XFA_desc* getDesc() const {  return m_desc.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_font* getFont() const {  return m_font.getValue(); }
    const XFA_keep* getKeep() const {  return m_keep.getValue(); }
    const XFA_margin* getMargin() const {  return m_margin.getValue(); }
    const XFA_para* getPara() const {  return m_para.getValue(); }
    const XFA_traversal* getTraversal() const {  return m_traversal.getValue(); }
    const XFA_ui* getUi() const {  return m_ui.getValue(); }
    const XFA_value* getValue() const {  return m_value.getValue(); }
    const std::vector<XFA_Node<XFA_setProperty>>& getSetProperty() const {  return m_setProperty; }

    static std::optional<XFA_draw> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<ANCHORTYPE> m_anchorType;
    XFA_Attribute<PDFInteger> m_colSpan;
    XFA_Attribute<XFA_Measurement> m_h;
    XFA_Attribute<HALIGN> m_hAlign;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_locale;
    XFA_Attribute<XFA_Measurement> m_maxH;
    XFA_Attribute<XFA_Measurement> m_maxW;
    XFA_Attribute<XFA_Measurement> m_minH;
    XFA_Attribute<XFA_Measurement> m_minW;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<PRESENCE> m_presence;
    XFA_Attribute<QString> m_relevant;
    XFA_Attribute<PDFReal> m_rotate;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;
    XFA_Attribute<XFA_Measurement> m_w;
    XFA_Attribute<XFA_Measurement> m_x;
    XFA_Attribute<XFA_Measurement> m_y;

    /* subnodes */
    XFA_Node<XFA_assist> m_assist;
    XFA_Node<XFA_border> m_border;
    XFA_Node<XFA_caption> m_caption;
    XFA_Node<XFA_desc> m_desc;
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_font> m_font;
    XFA_Node<XFA_keep> m_keep;
    XFA_Node<XFA_margin> m_margin;
    XFA_Node<XFA_para> m_para;
    XFA_Node<XFA_traversal> m_traversal;
    XFA_Node<XFA_ui> m_ui;
    XFA_Node<XFA_value> m_value;
    std::vector<XFA_Node<XFA_setProperty>> m_setProperty;
};

std::optional<XFA_draw> XFA_draw::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_draw myClass;

    // load attributes
    parseAttribute(element, "anchorType", myClass.m_anchorType, "topleft");
    parseAttribute(element, "colSpan", myClass.m_colSpan, "1");
    parseAttribute(element, "h", myClass.m_h, "0in");
    parseAttribute(element, "hAlign", myClass.m_hAlign, "left");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "locale", myClass.m_locale, "");
    parseAttribute(element, "maxH", myClass.m_maxH, "0in");
    parseAttribute(element, "maxW", myClass.m_maxW, "0in");
    parseAttribute(element, "minH", myClass.m_minH, "0in");
    parseAttribute(element, "minW", myClass.m_minW, "0in");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "presence", myClass.m_presence, "visible");
    parseAttribute(element, "relevant", myClass.m_relevant, "");
    parseAttribute(element, "rotate", myClass.m_rotate, "0");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");
    parseAttribute(element, "w", myClass.m_w, "0in");
    parseAttribute(element, "x", myClass.m_x, "0in");
    parseAttribute(element, "y", myClass.m_y, "0in");

    // load items
    parseItem(element, "assist", myClass.m_assist);
    parseItem(element, "border", myClass.m_border);
    parseItem(element, "caption", myClass.m_caption);
    parseItem(element, "desc", myClass.m_desc);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "font", myClass.m_font);
    parseItem(element, "keep", myClass.m_keep);
    parseItem(element, "margin", myClass.m_margin);
    parseItem(element, "para", myClass.m_para);
    parseItem(element, "traversal", myClass.m_traversal);
    parseItem(element, "ui", myClass.m_ui);
    parseItem(element, "value", myClass.m_value);
    parseItem(element, "setProperty", myClass.m_setProperty);
    return myClass;
}


class XFA_edge : public XFA_BaseNode
{
public:

    const CAP* getCap() const {  return m_cap.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const PRESENCE* getPresence() const {  return m_presence.getValue(); }
    const STROKE* getStroke() const {  return m_stroke.getValue(); }
    const XFA_Measurement* getThickness() const {  return m_thickness.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_color* getColor() const {  return m_color.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }

    static std::optional<XFA_edge> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<CAP> m_cap;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<PRESENCE> m_presence;
    XFA_Attribute<STROKE> m_stroke;
    XFA_Attribute<XFA_Measurement> m_thickness;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_color> m_color;
    XFA_Node<XFA_extras> m_extras;
};

std::optional<XFA_edge> XFA_edge::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_edge myClass;

    // load attributes
    parseAttribute(element, "cap", myClass.m_cap, "square");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "presence", myClass.m_presence, "visible");
    parseAttribute(element, "stroke", myClass.m_stroke, "solid");
    parseAttribute(element, "thickness", myClass.m_thickness, "0.5pt");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "color", myClass.m_color);
    parseItem(element, "extras", myClass.m_extras);
    return myClass;
}


class XFA_encoding : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_encoding> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_encoding> XFA_encoding::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_encoding myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_encodings : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const TYPE* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const std::vector<XFA_Node<XFA_encoding>>& getEncoding() const {  return m_encoding; }

    static std::optional<XFA_encodings> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<TYPE> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    std::vector<XFA_Node<XFA_encoding>> m_encoding;
};

std::optional<XFA_encodings> XFA_encodings::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_encodings myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "type", myClass.m_type, "optional");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "encoding", myClass.m_encoding);
    return myClass;
}


class XFA_encrypt : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_certificate* getCertificate() const {  return m_certificate.getValue(); }

    static std::optional<XFA_encrypt> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_certificate> m_certificate;
};

std::optional<XFA_encrypt> XFA_encrypt::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_encrypt myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "certificate", myClass.m_certificate);
    return myClass;
}


class XFA_encryptData : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const OPERATION* getOperation() const {  return m_operation.getValue(); }
    const QString* getTarget() const {  return m_target.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_filter* getFilter() const {  return m_filter.getValue(); }
    const XFA_manifest* getManifest() const {  return m_manifest.getValue(); }

    static std::optional<XFA_encryptData> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<OPERATION> m_operation;
    XFA_Attribute<QString> m_target;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_filter> m_filter;
    XFA_Node<XFA_manifest> m_manifest;
};

std::optional<XFA_encryptData> XFA_encryptData::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_encryptData myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "operation", myClass.m_operation, "encrypt");
    parseAttribute(element, "target", myClass.m_target, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "filter", myClass.m_filter);
    parseItem(element, "manifest", myClass.m_manifest);
    return myClass;
}


class XFA_encryption : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const TYPE* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const std::vector<XFA_Node<XFA_certificate>>& getCertificate() const {  return m_certificate; }

    static std::optional<XFA_encryption> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<TYPE> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    std::vector<XFA_Node<XFA_certificate>> m_certificate;
};

std::optional<XFA_encryption> XFA_encryption::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_encryption myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "type", myClass.m_type, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "certificate", myClass.m_certificate);
    return myClass;
}


class XFA_encryptionMethod : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_encryptionMethod> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_encryptionMethod> XFA_encryptionMethod::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_encryptionMethod myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_encryptionMethods : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const TYPE* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const std::vector<XFA_Node<XFA_encryptionMethod>>& getEncryptionMethod() const {  return m_encryptionMethod; }

    static std::optional<XFA_encryptionMethods> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<TYPE> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    std::vector<XFA_Node<XFA_encryptionMethod>> m_encryptionMethod;
};

std::optional<XFA_encryptionMethods> XFA_encryptionMethods::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_encryptionMethods myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "type", myClass.m_type, "optional");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "encryptionMethod", myClass.m_encryptionMethod);
    return myClass;
}


class XFA_event : public XFA_BaseNode
{
public:

    const ACTIVITY* getActivity() const {  return m_activity.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const LISTEN* getListen() const {  return m_listen.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getRef() const {  return m_ref.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_encryptData* getEncryptData() const {  return m_encryptData.getValue(); }
    const XFA_execute* getExecute() const {  return m_execute.getValue(); }
    const XFA_script* getScript() const {  return m_script.getValue(); }
    const XFA_signData* getSignData() const {  return m_signData.getValue(); }
    const XFA_submit* getSubmit() const {  return m_submit.getValue(); }

    static std::optional<XFA_event> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<ACTIVITY> m_activity;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<LISTEN> m_listen;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_ref;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_encryptData> m_encryptData;
    XFA_Node<XFA_execute> m_execute;
    XFA_Node<XFA_script> m_script;
    XFA_Node<XFA_signData> m_signData;
    XFA_Node<XFA_submit> m_submit;
};

std::optional<XFA_event> XFA_event::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_event myClass;

    // load attributes
    parseAttribute(element, "activity", myClass.m_activity, "click");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "listen", myClass.m_listen, "refOnly");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "ref", myClass.m_ref, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "encryptData", myClass.m_encryptData);
    parseItem(element, "execute", myClass.m_execute);
    parseItem(element, "script", myClass.m_script);
    parseItem(element, "signData", myClass.m_signData);
    parseItem(element, "submit", myClass.m_submit);
    return myClass;
}


class XFA_exData : public XFA_BaseNode
{
public:

    const QString* getContentType() const {  return m_contentType.getValue(); }
    const QString* getHref() const {  return m_href.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const PDFInteger* getMaxLength() const {  return m_maxLength.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getRid() const {  return m_rid.getValue(); }
    const TRANSFERENCODING* getTransferEncoding() const {  return m_transferEncoding.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_exData> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_contentType;
    XFA_Attribute<QString> m_href;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<PDFInteger> m_maxLength;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_rid;
    XFA_Attribute<TRANSFERENCODING> m_transferEncoding;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_exData> XFA_exData::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_exData myClass;

    // load attributes
    parseAttribute(element, "contentType", myClass.m_contentType, "");
    parseAttribute(element, "href", myClass.m_href, "");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "maxLength", myClass.m_maxLength, "-1");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "rid", myClass.m_rid, "");
    parseAttribute(element, "transferEncoding", myClass.m_transferEncoding, "none");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_exObject : public XFA_BaseNode
{
public:

    const QString* getArchive() const {  return m_archive.getValue(); }
    const QString* getClassId() const {  return m_classId.getValue(); }
    const QString* getCodeBase() const {  return m_codeBase.getValue(); }
    const QString* getCodeType() const {  return m_codeType.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const std::vector<XFA_Node<XFA_boolean>>& getBoolean() const {  return m_boolean; }
    const std::vector<XFA_Node<XFA_date>>& getDate() const {  return m_date; }
    const std::vector<XFA_Node<XFA_dateTime>>& getDateTime() const {  return m_dateTime; }
    const std::vector<XFA_Node<XFA_decimal>>& getDecimal() const {  return m_decimal; }
    const std::vector<XFA_Node<XFA_exData>>& getExData() const {  return m_exData; }
    const std::vector<XFA_Node<XFA_exObject>>& getExObject() const {  return m_exObject; }
    const std::vector<XFA_Node<XFA_float>>& getFloat() const {  return m_float; }
    const std::vector<XFA_Node<XFA_image>>& getImage() const {  return m_image; }
    const std::vector<XFA_Node<XFA_integer>>& getInteger() const {  return m_integer; }
    const std::vector<XFA_Node<XFA_text>>& getText() const {  return m_text; }
    const std::vector<XFA_Node<XFA_time>>& getTime() const {  return m_time; }

    static std::optional<XFA_exObject> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_archive;
    XFA_Attribute<QString> m_classId;
    XFA_Attribute<QString> m_codeBase;
    XFA_Attribute<QString> m_codeType;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
    std::vector<XFA_Node<XFA_boolean>> m_boolean;
    std::vector<XFA_Node<XFA_date>> m_date;
    std::vector<XFA_Node<XFA_dateTime>> m_dateTime;
    std::vector<XFA_Node<XFA_decimal>> m_decimal;
    std::vector<XFA_Node<XFA_exData>> m_exData;
    std::vector<XFA_Node<XFA_exObject>> m_exObject;
    std::vector<XFA_Node<XFA_float>> m_float;
    std::vector<XFA_Node<XFA_image>> m_image;
    std::vector<XFA_Node<XFA_integer>> m_integer;
    std::vector<XFA_Node<XFA_text>> m_text;
    std::vector<XFA_Node<XFA_time>> m_time;
};

std::optional<XFA_exObject> XFA_exObject::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_exObject myClass;

    // load attributes
    parseAttribute(element, "archive", myClass.m_archive, "");
    parseAttribute(element, "classId", myClass.m_classId, "");
    parseAttribute(element, "codeBase", myClass.m_codeBase, "");
    parseAttribute(element, "codeType", myClass.m_codeType, "");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "boolean", myClass.m_boolean);
    parseItem(element, "date", myClass.m_date);
    parseItem(element, "dateTime", myClass.m_dateTime);
    parseItem(element, "decimal", myClass.m_decimal);
    parseItem(element, "exData", myClass.m_exData);
    parseItem(element, "exObject", myClass.m_exObject);
    parseItem(element, "float", myClass.m_float);
    parseItem(element, "image", myClass.m_image);
    parseItem(element, "integer", myClass.m_integer);
    parseItem(element, "text", myClass.m_text);
    parseItem(element, "time", myClass.m_time);
    return myClass;
}


class XFA_exclGroup : public XFA_BaseNode
{
public:

    const ACCESS* getAccess() const {  return m_access.getValue(); }
    const QString* getAccessKey() const {  return m_accessKey.getValue(); }
    const ANCHORTYPE* getAnchorType() const {  return m_anchorType.getValue(); }
    const PDFInteger* getColSpan() const {  return m_colSpan.getValue(); }
    const XFA_Measurement* getH() const {  return m_h.getValue(); }
    const HALIGN* getHAlign() const {  return m_hAlign.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const LAYOUT* getLayout() const {  return m_layout.getValue(); }
    const XFA_Measurement* getMaxH() const {  return m_maxH.getValue(); }
    const XFA_Measurement* getMaxW() const {  return m_maxW.getValue(); }
    const XFA_Measurement* getMinH() const {  return m_minH.getValue(); }
    const XFA_Measurement* getMinW() const {  return m_minW.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const PRESENCE* getPresence() const {  return m_presence.getValue(); }
    const QString* getRelevant() const {  return m_relevant.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }
    const XFA_Measurement* getW() const {  return m_w.getValue(); }
    const XFA_Measurement* getX() const {  return m_x.getValue(); }
    const XFA_Measurement* getY() const {  return m_y.getValue(); }

    const XFA_assist* getAssist() const {  return m_assist.getValue(); }
    const XFA_bind* getBind() const {  return m_bind.getValue(); }
    const XFA_border* getBorder() const {  return m_border.getValue(); }
    const XFA_calculate* getCalculate() const {  return m_calculate.getValue(); }
    const XFA_caption* getCaption() const {  return m_caption.getValue(); }
    const XFA_desc* getDesc() const {  return m_desc.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_margin* getMargin() const {  return m_margin.getValue(); }
    const XFA_para* getPara() const {  return m_para.getValue(); }
    const XFA_traversal* getTraversal() const {  return m_traversal.getValue(); }
    const XFA_validate* getValidate() const {  return m_validate.getValue(); }
    const std::vector<XFA_Node<XFA_connect>>& getConnect() const {  return m_connect; }
    const std::vector<XFA_Node<XFA_event>>& getEvent() const {  return m_event; }
    const std::vector<XFA_Node<XFA_field>>& getField() const {  return m_field; }
    const std::vector<XFA_Node<XFA_setProperty>>& getSetProperty() const {  return m_setProperty; }

    static std::optional<XFA_exclGroup> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<ACCESS> m_access;
    XFA_Attribute<QString> m_accessKey;
    XFA_Attribute<ANCHORTYPE> m_anchorType;
    XFA_Attribute<PDFInteger> m_colSpan;
    XFA_Attribute<XFA_Measurement> m_h;
    XFA_Attribute<HALIGN> m_hAlign;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<LAYOUT> m_layout;
    XFA_Attribute<XFA_Measurement> m_maxH;
    XFA_Attribute<XFA_Measurement> m_maxW;
    XFA_Attribute<XFA_Measurement> m_minH;
    XFA_Attribute<XFA_Measurement> m_minW;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<PRESENCE> m_presence;
    XFA_Attribute<QString> m_relevant;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;
    XFA_Attribute<XFA_Measurement> m_w;
    XFA_Attribute<XFA_Measurement> m_x;
    XFA_Attribute<XFA_Measurement> m_y;

    /* subnodes */
    XFA_Node<XFA_assist> m_assist;
    XFA_Node<XFA_bind> m_bind;
    XFA_Node<XFA_border> m_border;
    XFA_Node<XFA_calculate> m_calculate;
    XFA_Node<XFA_caption> m_caption;
    XFA_Node<XFA_desc> m_desc;
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_margin> m_margin;
    XFA_Node<XFA_para> m_para;
    XFA_Node<XFA_traversal> m_traversal;
    XFA_Node<XFA_validate> m_validate;
    std::vector<XFA_Node<XFA_connect>> m_connect;
    std::vector<XFA_Node<XFA_event>> m_event;
    std::vector<XFA_Node<XFA_field>> m_field;
    std::vector<XFA_Node<XFA_setProperty>> m_setProperty;
};

std::optional<XFA_exclGroup> XFA_exclGroup::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_exclGroup myClass;

    // load attributes
    parseAttribute(element, "access", myClass.m_access, "open");
    parseAttribute(element, "accessKey", myClass.m_accessKey, "");
    parseAttribute(element, "anchorType", myClass.m_anchorType, "topleft");
    parseAttribute(element, "colSpan", myClass.m_colSpan, "1");
    parseAttribute(element, "h", myClass.m_h, "0in");
    parseAttribute(element, "hAlign", myClass.m_hAlign, "left");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "layout", myClass.m_layout, "position");
    parseAttribute(element, "maxH", myClass.m_maxH, "0in");
    parseAttribute(element, "maxW", myClass.m_maxW, "0in");
    parseAttribute(element, "minH", myClass.m_minH, "0in");
    parseAttribute(element, "minW", myClass.m_minW, "0in");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "presence", myClass.m_presence, "visible");
    parseAttribute(element, "relevant", myClass.m_relevant, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");
    parseAttribute(element, "w", myClass.m_w, "0in");
    parseAttribute(element, "x", myClass.m_x, "0in");
    parseAttribute(element, "y", myClass.m_y, "0in");

    // load items
    parseItem(element, "assist", myClass.m_assist);
    parseItem(element, "bind", myClass.m_bind);
    parseItem(element, "border", myClass.m_border);
    parseItem(element, "calculate", myClass.m_calculate);
    parseItem(element, "caption", myClass.m_caption);
    parseItem(element, "desc", myClass.m_desc);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "margin", myClass.m_margin);
    parseItem(element, "para", myClass.m_para);
    parseItem(element, "traversal", myClass.m_traversal);
    parseItem(element, "validate", myClass.m_validate);
    parseItem(element, "connect", myClass.m_connect);
    parseItem(element, "event", myClass.m_event);
    parseItem(element, "field", myClass.m_field);
    parseItem(element, "setProperty", myClass.m_setProperty);
    return myClass;
}


class XFA_execute : public XFA_BaseNode
{
public:

    const QString* getConnection() const {  return m_connection.getValue(); }
    const EXECUTETYPE* getExecuteType() const {  return m_executeType.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const RUNAT* getRunAt() const {  return m_runAt.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    static std::optional<XFA_execute> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_connection;
    XFA_Attribute<EXECUTETYPE> m_executeType;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<RUNAT> m_runAt;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
};

std::optional<XFA_execute> XFA_execute::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_execute myClass;

    // load attributes
    parseAttribute(element, "connection", myClass.m_connection, "");
    parseAttribute(element, "executeType", myClass.m_executeType, "import");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "runAt", myClass.m_runAt, "client");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_extras : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const std::vector<XFA_Node<XFA_boolean>>& getBoolean() const {  return m_boolean; }
    const std::vector<XFA_Node<XFA_date>>& getDate() const {  return m_date; }
    const std::vector<XFA_Node<XFA_dateTime>>& getDateTime() const {  return m_dateTime; }
    const std::vector<XFA_Node<XFA_decimal>>& getDecimal() const {  return m_decimal; }
    const std::vector<XFA_Node<XFA_exData>>& getExData() const {  return m_exData; }
    const std::vector<XFA_Node<XFA_extras>>& getExtras() const {  return m_extras; }
    const std::vector<XFA_Node<XFA_float>>& getFloat() const {  return m_float; }
    const std::vector<XFA_Node<XFA_image>>& getImage() const {  return m_image; }
    const std::vector<XFA_Node<XFA_integer>>& getInteger() const {  return m_integer; }
    const std::vector<XFA_Node<XFA_text>>& getText() const {  return m_text; }
    const std::vector<XFA_Node<XFA_time>>& getTime() const {  return m_time; }

    static std::optional<XFA_extras> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    std::vector<XFA_Node<XFA_boolean>> m_boolean;
    std::vector<XFA_Node<XFA_date>> m_date;
    std::vector<XFA_Node<XFA_dateTime>> m_dateTime;
    std::vector<XFA_Node<XFA_decimal>> m_decimal;
    std::vector<XFA_Node<XFA_exData>> m_exData;
    std::vector<XFA_Node<XFA_extras>> m_extras;
    std::vector<XFA_Node<XFA_float>> m_float;
    std::vector<XFA_Node<XFA_image>> m_image;
    std::vector<XFA_Node<XFA_integer>> m_integer;
    std::vector<XFA_Node<XFA_text>> m_text;
    std::vector<XFA_Node<XFA_time>> m_time;
};

std::optional<XFA_extras> XFA_extras::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_extras myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "boolean", myClass.m_boolean);
    parseItem(element, "date", myClass.m_date);
    parseItem(element, "dateTime", myClass.m_dateTime);
    parseItem(element, "decimal", myClass.m_decimal);
    parseItem(element, "exData", myClass.m_exData);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "float", myClass.m_float);
    parseItem(element, "image", myClass.m_image);
    parseItem(element, "integer", myClass.m_integer);
    parseItem(element, "text", myClass.m_text);
    parseItem(element, "time", myClass.m_time);
    return myClass;
}


class XFA_field : public XFA_BaseNode
{
public:

    const ACCESS* getAccess() const {  return m_access.getValue(); }
    const QString* getAccessKey() const {  return m_accessKey.getValue(); }
    const ANCHORTYPE* getAnchorType() const {  return m_anchorType.getValue(); }
    const PDFInteger* getColSpan() const {  return m_colSpan.getValue(); }
    const XFA_Measurement* getH() const {  return m_h.getValue(); }
    const HALIGN* getHAlign() const {  return m_hAlign.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getLocale() const {  return m_locale.getValue(); }
    const XFA_Measurement* getMaxH() const {  return m_maxH.getValue(); }
    const XFA_Measurement* getMaxW() const {  return m_maxW.getValue(); }
    const XFA_Measurement* getMinH() const {  return m_minH.getValue(); }
    const XFA_Measurement* getMinW() const {  return m_minW.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const PRESENCE* getPresence() const {  return m_presence.getValue(); }
    const QString* getRelevant() const {  return m_relevant.getValue(); }
    const PDFReal* getRotate() const {  return m_rotate.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }
    const XFA_Measurement* getW() const {  return m_w.getValue(); }
    const XFA_Measurement* getX() const {  return m_x.getValue(); }
    const XFA_Measurement* getY() const {  return m_y.getValue(); }

    const XFA_assist* getAssist() const {  return m_assist.getValue(); }
    const XFA_bind* getBind() const {  return m_bind.getValue(); }
    const XFA_border* getBorder() const {  return m_border.getValue(); }
    const XFA_calculate* getCalculate() const {  return m_calculate.getValue(); }
    const XFA_caption* getCaption() const {  return m_caption.getValue(); }
    const XFA_desc* getDesc() const {  return m_desc.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_font* getFont() const {  return m_font.getValue(); }
    const XFA_format* getFormat() const {  return m_format.getValue(); }
    const std::vector<XFA_Node<XFA_items>>& getItems() const {  return m_items; }
    const XFA_keep* getKeep() const {  return m_keep.getValue(); }
    const XFA_margin* getMargin() const {  return m_margin.getValue(); }
    const XFA_para* getPara() const {  return m_para.getValue(); }
    const XFA_traversal* getTraversal() const {  return m_traversal.getValue(); }
    const XFA_ui* getUi() const {  return m_ui.getValue(); }
    const XFA_validate* getValidate() const {  return m_validate.getValue(); }
    const XFA_value* getValue() const {  return m_value.getValue(); }
    const std::vector<XFA_Node<XFA_bindItems>>& getBindItems() const {  return m_bindItems; }
    const std::vector<XFA_Node<XFA_connect>>& getConnect() const {  return m_connect; }
    const std::vector<XFA_Node<XFA_event>>& getEvent() const {  return m_event; }
    const std::vector<XFA_Node<XFA_setProperty>>& getSetProperty() const {  return m_setProperty; }

    static std::optional<XFA_field> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<ACCESS> m_access;
    XFA_Attribute<QString> m_accessKey;
    XFA_Attribute<ANCHORTYPE> m_anchorType;
    XFA_Attribute<PDFInteger> m_colSpan;
    XFA_Attribute<XFA_Measurement> m_h;
    XFA_Attribute<HALIGN> m_hAlign;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_locale;
    XFA_Attribute<XFA_Measurement> m_maxH;
    XFA_Attribute<XFA_Measurement> m_maxW;
    XFA_Attribute<XFA_Measurement> m_minH;
    XFA_Attribute<XFA_Measurement> m_minW;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<PRESENCE> m_presence;
    XFA_Attribute<QString> m_relevant;
    XFA_Attribute<PDFReal> m_rotate;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;
    XFA_Attribute<XFA_Measurement> m_w;
    XFA_Attribute<XFA_Measurement> m_x;
    XFA_Attribute<XFA_Measurement> m_y;

    /* subnodes */
    XFA_Node<XFA_assist> m_assist;
    XFA_Node<XFA_bind> m_bind;
    XFA_Node<XFA_border> m_border;
    XFA_Node<XFA_calculate> m_calculate;
    XFA_Node<XFA_caption> m_caption;
    XFA_Node<XFA_desc> m_desc;
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_font> m_font;
    XFA_Node<XFA_format> m_format;
    std::vector<XFA_Node<XFA_items>> m_items;
    XFA_Node<XFA_keep> m_keep;
    XFA_Node<XFA_margin> m_margin;
    XFA_Node<XFA_para> m_para;
    XFA_Node<XFA_traversal> m_traversal;
    XFA_Node<XFA_ui> m_ui;
    XFA_Node<XFA_validate> m_validate;
    XFA_Node<XFA_value> m_value;
    std::vector<XFA_Node<XFA_bindItems>> m_bindItems;
    std::vector<XFA_Node<XFA_connect>> m_connect;
    std::vector<XFA_Node<XFA_event>> m_event;
    std::vector<XFA_Node<XFA_setProperty>> m_setProperty;
};

std::optional<XFA_field> XFA_field::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_field myClass;

    // load attributes
    parseAttribute(element, "access", myClass.m_access, "open");
    parseAttribute(element, "accessKey", myClass.m_accessKey, "");
    parseAttribute(element, "anchorType", myClass.m_anchorType, "topleft");
    parseAttribute(element, "colSpan", myClass.m_colSpan, "1");
    parseAttribute(element, "h", myClass.m_h, "0in");
    parseAttribute(element, "hAlign", myClass.m_hAlign, "left");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "locale", myClass.m_locale, "");
    parseAttribute(element, "maxH", myClass.m_maxH, "0in");
    parseAttribute(element, "maxW", myClass.m_maxW, "0in");
    parseAttribute(element, "minH", myClass.m_minH, "0in");
    parseAttribute(element, "minW", myClass.m_minW, "0in");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "presence", myClass.m_presence, "visible");
    parseAttribute(element, "relevant", myClass.m_relevant, "");
    parseAttribute(element, "rotate", myClass.m_rotate, "0");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");
    parseAttribute(element, "w", myClass.m_w, "0in");
    parseAttribute(element, "x", myClass.m_x, "0in");
    parseAttribute(element, "y", myClass.m_y, "0in");

    // load items
    parseItem(element, "assist", myClass.m_assist);
    parseItem(element, "bind", myClass.m_bind);
    parseItem(element, "border", myClass.m_border);
    parseItem(element, "calculate", myClass.m_calculate);
    parseItem(element, "caption", myClass.m_caption);
    parseItem(element, "desc", myClass.m_desc);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "font", myClass.m_font);
    parseItem(element, "format", myClass.m_format);
    parseItem(element, "items", myClass.m_items);
    parseItem(element, "keep", myClass.m_keep);
    parseItem(element, "margin", myClass.m_margin);
    parseItem(element, "para", myClass.m_para);
    parseItem(element, "traversal", myClass.m_traversal);
    parseItem(element, "ui", myClass.m_ui);
    parseItem(element, "validate", myClass.m_validate);
    parseItem(element, "value", myClass.m_value);
    parseItem(element, "bindItems", myClass.m_bindItems);
    parseItem(element, "connect", myClass.m_connect);
    parseItem(element, "event", myClass.m_event);
    parseItem(element, "setProperty", myClass.m_setProperty);
    return myClass;
}


class XFA_fill : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const PRESENCE* getPresence() const {  return m_presence.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_color* getColor() const {  return m_color.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_linear* getLinear() const {  return m_linear.getValue(); }
    const XFA_pattern* getPattern() const {  return m_pattern.getValue(); }
    const XFA_radial* getRadial() const {  return m_radial.getValue(); }
    const XFA_solid* getSolid() const {  return m_solid.getValue(); }
    const XFA_stipple* getStipple() const {  return m_stipple.getValue(); }

    static std::optional<XFA_fill> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<PRESENCE> m_presence;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_color> m_color;
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_linear> m_linear;
    XFA_Node<XFA_pattern> m_pattern;
    XFA_Node<XFA_radial> m_radial;
    XFA_Node<XFA_solid> m_solid;
    XFA_Node<XFA_stipple> m_stipple;
};

std::optional<XFA_fill> XFA_fill::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_fill myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "presence", myClass.m_presence, "visible");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "color", myClass.m_color);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "linear", myClass.m_linear);
    parseItem(element, "pattern", myClass.m_pattern);
    parseItem(element, "radial", myClass.m_radial);
    parseItem(element, "solid", myClass.m_solid);
    parseItem(element, "stipple", myClass.m_stipple);
    return myClass;
}


class XFA_filter : public XFA_BaseNode
{
public:

    const QString* getAddRevocationInfo() const {  return m_addRevocationInfo.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }
    const QString* getVersion() const {  return m_version.getValue(); }

    const XFA_appearanceFilter* getAppearanceFilter() const {  return m_appearanceFilter.getValue(); }
    const XFA_certificates* getCertificates() const {  return m_certificates.getValue(); }
    const XFA_digestMethods* getDigestMethods() const {  return m_digestMethods.getValue(); }
    const XFA_encodings* getEncodings() const {  return m_encodings.getValue(); }
    const XFA_encryptionMethods* getEncryptionMethods() const {  return m_encryptionMethods.getValue(); }
    const XFA_handler* getHandler() const {  return m_handler.getValue(); }
    const XFA_lockDocument* getLockDocument() const {  return m_lockDocument.getValue(); }
    const XFA_mdp* getMdp() const {  return m_mdp.getValue(); }
    const XFA_reasons* getReasons() const {  return m_reasons.getValue(); }
    const XFA_timeStamp* getTimeStamp() const {  return m_timeStamp.getValue(); }

    static std::optional<XFA_filter> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_addRevocationInfo;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;
    XFA_Attribute<QString> m_version;

    /* subnodes */
    XFA_Node<XFA_appearanceFilter> m_appearanceFilter;
    XFA_Node<XFA_certificates> m_certificates;
    XFA_Node<XFA_digestMethods> m_digestMethods;
    XFA_Node<XFA_encodings> m_encodings;
    XFA_Node<XFA_encryptionMethods> m_encryptionMethods;
    XFA_Node<XFA_handler> m_handler;
    XFA_Node<XFA_lockDocument> m_lockDocument;
    XFA_Node<XFA_mdp> m_mdp;
    XFA_Node<XFA_reasons> m_reasons;
    XFA_Node<XFA_timeStamp> m_timeStamp;
};

std::optional<XFA_filter> XFA_filter::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_filter myClass;

    // load attributes
    parseAttribute(element, "addRevocationInfo", myClass.m_addRevocationInfo, "");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");
    parseAttribute(element, "version", myClass.m_version, "");

    // load items
    parseItem(element, "appearanceFilter", myClass.m_appearanceFilter);
    parseItem(element, "certificates", myClass.m_certificates);
    parseItem(element, "digestMethods", myClass.m_digestMethods);
    parseItem(element, "encodings", myClass.m_encodings);
    parseItem(element, "encryptionMethods", myClass.m_encryptionMethods);
    parseItem(element, "handler", myClass.m_handler);
    parseItem(element, "lockDocument", myClass.m_lockDocument);
    parseItem(element, "mdp", myClass.m_mdp);
    parseItem(element, "reasons", myClass.m_reasons);
    parseItem(element, "timeStamp", myClass.m_timeStamp);
    return myClass;
}


class XFA_float : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_float> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_float> XFA_float::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_float myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_font : public XFA_BaseNode
{
public:

    const XFA_Measurement* getBaselineShift() const {  return m_baselineShift.getValue(); }
    const QString* getFontHorizontalScale() const {  return m_fontHorizontalScale.getValue(); }
    const QString* getFontVerticalScale() const {  return m_fontVerticalScale.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const KERNINGMODE* getKerningMode() const {  return m_kerningMode.getValue(); }
    const QString* getLetterSpacing() const {  return m_letterSpacing.getValue(); }
    const LINETHROUGH* getLineThrough() const {  return m_lineThrough.getValue(); }
    const LINETHROUGHPERIOD* getLineThroughPeriod() const {  return m_lineThroughPeriod.getValue(); }
    const OVERLINE* getOverline() const {  return m_overline.getValue(); }
    const OVERLINEPERIOD* getOverlinePeriod() const {  return m_overlinePeriod.getValue(); }
    const POSTURE* getPosture() const {  return m_posture.getValue(); }
    const XFA_Measurement* getSize() const {  return m_size.getValue(); }
    const QString* getTypeface() const {  return m_typeface.getValue(); }
    const UNDERLINE* getUnderline() const {  return m_underline.getValue(); }
    const UNDERLINEPERIOD* getUnderlinePeriod() const {  return m_underlinePeriod.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }
    const WEIGHT* getWeight() const {  return m_weight.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_fill* getFill() const {  return m_fill.getValue(); }

    static std::optional<XFA_font> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<XFA_Measurement> m_baselineShift;
    XFA_Attribute<QString> m_fontHorizontalScale;
    XFA_Attribute<QString> m_fontVerticalScale;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<KERNINGMODE> m_kerningMode;
    XFA_Attribute<QString> m_letterSpacing;
    XFA_Attribute<LINETHROUGH> m_lineThrough;
    XFA_Attribute<LINETHROUGHPERIOD> m_lineThroughPeriod;
    XFA_Attribute<OVERLINE> m_overline;
    XFA_Attribute<OVERLINEPERIOD> m_overlinePeriod;
    XFA_Attribute<POSTURE> m_posture;
    XFA_Attribute<XFA_Measurement> m_size;
    XFA_Attribute<QString> m_typeface;
    XFA_Attribute<UNDERLINE> m_underline;
    XFA_Attribute<UNDERLINEPERIOD> m_underlinePeriod;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;
    XFA_Attribute<WEIGHT> m_weight;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_fill> m_fill;
};

std::optional<XFA_font> XFA_font::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_font myClass;

    // load attributes
    parseAttribute(element, "baselineShift", myClass.m_baselineShift, "0in");
    parseAttribute(element, "fontHorizontalScale", myClass.m_fontHorizontalScale, "");
    parseAttribute(element, "fontVerticalScale", myClass.m_fontVerticalScale, "");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "kerningMode", myClass.m_kerningMode, "none");
    parseAttribute(element, "letterSpacing", myClass.m_letterSpacing, "");
    parseAttribute(element, "lineThrough", myClass.m_lineThrough, "0");
    parseAttribute(element, "lineThroughPeriod", myClass.m_lineThroughPeriod, "all");
    parseAttribute(element, "overline", myClass.m_overline, "0");
    parseAttribute(element, "overlinePeriod", myClass.m_overlinePeriod, "all");
    parseAttribute(element, "posture", myClass.m_posture, "normal");
    parseAttribute(element, "size", myClass.m_size, "10pt");
    parseAttribute(element, "typeface", myClass.m_typeface, "");
    parseAttribute(element, "underline", myClass.m_underline, "0");
    parseAttribute(element, "underlinePeriod", myClass.m_underlinePeriod, "all");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");
    parseAttribute(element, "weight", myClass.m_weight, "normal");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "fill", myClass.m_fill);
    return myClass;
}


class XFA_format : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_picture* getPicture() const {  return m_picture.getValue(); }

    static std::optional<XFA_format> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_picture> m_picture;
};

std::optional<XFA_format> XFA_format::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_format myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "picture", myClass.m_picture);
    return myClass;
}


class XFA_handler : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const TYPE* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_handler> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<TYPE> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_handler> XFA_handler::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_handler myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "type", myClass.m_type, "optional");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_hyphenation : public XFA_BaseNode
{
public:

    const bool* getExcludeAllCaps() const {  return m_excludeAllCaps.getValue(); }
    const bool* getExcludeInitialCap() const {  return m_excludeInitialCap.getValue(); }
    const bool* getHyphenate() const {  return m_hyphenate.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const PDFInteger* getPushCharacterCount() const {  return m_pushCharacterCount.getValue(); }
    const PDFInteger* getRemainCharacterCount() const {  return m_remainCharacterCount.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }
    const PDFInteger* getWordCharacterCount() const {  return m_wordCharacterCount.getValue(); }


    static std::optional<XFA_hyphenation> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<bool> m_excludeAllCaps;
    XFA_Attribute<bool> m_excludeInitialCap;
    XFA_Attribute<bool> m_hyphenate;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<PDFInteger> m_pushCharacterCount;
    XFA_Attribute<PDFInteger> m_remainCharacterCount;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;
    XFA_Attribute<PDFInteger> m_wordCharacterCount;

    /* subnodes */
};

std::optional<XFA_hyphenation> XFA_hyphenation::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_hyphenation myClass;

    // load attributes
    parseAttribute(element, "excludeAllCaps", myClass.m_excludeAllCaps, "0");
    parseAttribute(element, "excludeInitialCap", myClass.m_excludeInitialCap, "0");
    parseAttribute(element, "hyphenate", myClass.m_hyphenate, "0");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "pushCharacterCount", myClass.m_pushCharacterCount, "3");
    parseAttribute(element, "remainCharacterCount", myClass.m_remainCharacterCount, "3");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");
    parseAttribute(element, "wordCharacterCount", myClass.m_wordCharacterCount, "7");

    // load items
    return myClass;
}


class XFA_image : public XFA_BaseNode
{
public:

    const ASPECT* getAspect() const {  return m_aspect.getValue(); }
    const QString* getContentType() const {  return m_contentType.getValue(); }
    const QString* getHref() const {  return m_href.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const TRANSFERENCODING1* getTransferEncoding() const {  return m_transferEncoding.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_image> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<ASPECT> m_aspect;
    XFA_Attribute<QString> m_contentType;
    XFA_Attribute<QString> m_href;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<TRANSFERENCODING1> m_transferEncoding;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_image> XFA_image::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_image myClass;

    // load attributes
    parseAttribute(element, "aspect", myClass.m_aspect, "fit");
    parseAttribute(element, "contentType", myClass.m_contentType, "");
    parseAttribute(element, "href", myClass.m_href, "");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "transferEncoding", myClass.m_transferEncoding, "base64");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_imageEdit : public XFA_BaseNode
{
public:

    const DATA* getData() const {  return m_data.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_border* getBorder() const {  return m_border.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_margin* getMargin() const {  return m_margin.getValue(); }

    static std::optional<XFA_imageEdit> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<DATA> m_data;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_border> m_border;
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_margin> m_margin;
};

std::optional<XFA_imageEdit> XFA_imageEdit::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_imageEdit myClass;

    // load attributes
    parseAttribute(element, "data", myClass.m_data, "link");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "border", myClass.m_border);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "margin", myClass.m_margin);
    return myClass;
}


class XFA_integer : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_integer> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_integer> XFA_integer::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_integer myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_issuers : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const TYPE* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const std::vector<XFA_Node<XFA_certificate>>& getCertificate() const {  return m_certificate; }

    static std::optional<XFA_issuers> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<TYPE> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    std::vector<XFA_Node<XFA_certificate>> m_certificate;
};

std::optional<XFA_issuers> XFA_issuers::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_issuers myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "type", myClass.m_type, "optional");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "certificate", myClass.m_certificate);
    return myClass;
}


class XFA_items : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const PRESENCE* getPresence() const {  return m_presence.getValue(); }
    const QString* getRef() const {  return m_ref.getValue(); }
    const bool* getSave() const {  return m_save.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const std::vector<XFA_Node<XFA_boolean>>& getBoolean() const {  return m_boolean; }
    const std::vector<XFA_Node<XFA_date>>& getDate() const {  return m_date; }
    const std::vector<XFA_Node<XFA_dateTime>>& getDateTime() const {  return m_dateTime; }
    const std::vector<XFA_Node<XFA_decimal>>& getDecimal() const {  return m_decimal; }
    const std::vector<XFA_Node<XFA_exData>>& getExData() const {  return m_exData; }
    const std::vector<XFA_Node<XFA_float>>& getFloat() const {  return m_float; }
    const std::vector<XFA_Node<XFA_image>>& getImage() const {  return m_image; }
    const std::vector<XFA_Node<XFA_integer>>& getInteger() const {  return m_integer; }
    const std::vector<XFA_Node<XFA_text>>& getText() const {  return m_text; }
    const std::vector<XFA_Node<XFA_time>>& getTime() const {  return m_time; }

    static std::optional<XFA_items> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<PRESENCE> m_presence;
    XFA_Attribute<QString> m_ref;
    XFA_Attribute<bool> m_save;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    std::vector<XFA_Node<XFA_boolean>> m_boolean;
    std::vector<XFA_Node<XFA_date>> m_date;
    std::vector<XFA_Node<XFA_dateTime>> m_dateTime;
    std::vector<XFA_Node<XFA_decimal>> m_decimal;
    std::vector<XFA_Node<XFA_exData>> m_exData;
    std::vector<XFA_Node<XFA_float>> m_float;
    std::vector<XFA_Node<XFA_image>> m_image;
    std::vector<XFA_Node<XFA_integer>> m_integer;
    std::vector<XFA_Node<XFA_text>> m_text;
    std::vector<XFA_Node<XFA_time>> m_time;
};

std::optional<XFA_items> XFA_items::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_items myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "presence", myClass.m_presence, "visible");
    parseAttribute(element, "ref", myClass.m_ref, "");
    parseAttribute(element, "save", myClass.m_save, "0");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "boolean", myClass.m_boolean);
    parseItem(element, "date", myClass.m_date);
    parseItem(element, "dateTime", myClass.m_dateTime);
    parseItem(element, "decimal", myClass.m_decimal);
    parseItem(element, "exData", myClass.m_exData);
    parseItem(element, "float", myClass.m_float);
    parseItem(element, "image", myClass.m_image);
    parseItem(element, "integer", myClass.m_integer);
    parseItem(element, "text", myClass.m_text);
    parseItem(element, "time", myClass.m_time);
    return myClass;
}


class XFA_keep : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const INTACT* getIntact() const {  return m_intact.getValue(); }
    const NEXT* getNext() const {  return m_next.getValue(); }
    const PREVIOUS* getPrevious() const {  return m_previous.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }

    static std::optional<XFA_keep> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<INTACT> m_intact;
    XFA_Attribute<NEXT> m_next;
    XFA_Attribute<PREVIOUS> m_previous;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
};

std::optional<XFA_keep> XFA_keep::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_keep myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "intact", myClass.m_intact, "none");
    parseAttribute(element, "next", myClass.m_next, "none");
    parseAttribute(element, "previous", myClass.m_previous, "none");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    return myClass;
}


class XFA_keyUsage : public XFA_BaseNode
{
public:

    const QString* getCrlSign() const {  return m_crlSign.getValue(); }
    const QString* getDataEncipherment() const {  return m_dataEncipherment.getValue(); }
    const QString* getDecipherOnly() const {  return m_decipherOnly.getValue(); }
    const QString* getDigitalSignature() const {  return m_digitalSignature.getValue(); }
    const QString* getEncipherOnly() const {  return m_encipherOnly.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getKeyAgreement() const {  return m_keyAgreement.getValue(); }
    const QString* getKeyCertSign() const {  return m_keyCertSign.getValue(); }
    const QString* getKeyEncipherment() const {  return m_keyEncipherment.getValue(); }
    const QString* getNonRepudiation() const {  return m_nonRepudiation.getValue(); }
    const TYPE* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    static std::optional<XFA_keyUsage> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_crlSign;
    XFA_Attribute<QString> m_dataEncipherment;
    XFA_Attribute<QString> m_decipherOnly;
    XFA_Attribute<QString> m_digitalSignature;
    XFA_Attribute<QString> m_encipherOnly;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_keyAgreement;
    XFA_Attribute<QString> m_keyCertSign;
    XFA_Attribute<QString> m_keyEncipherment;
    XFA_Attribute<QString> m_nonRepudiation;
    XFA_Attribute<TYPE> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
};

std::optional<XFA_keyUsage> XFA_keyUsage::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_keyUsage myClass;

    // load attributes
    parseAttribute(element, "crlSign", myClass.m_crlSign, "");
    parseAttribute(element, "dataEncipherment", myClass.m_dataEncipherment, "");
    parseAttribute(element, "decipherOnly", myClass.m_decipherOnly, "");
    parseAttribute(element, "digitalSignature", myClass.m_digitalSignature, "");
    parseAttribute(element, "encipherOnly", myClass.m_encipherOnly, "");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "keyAgreement", myClass.m_keyAgreement, "");
    parseAttribute(element, "keyCertSign", myClass.m_keyCertSign, "");
    parseAttribute(element, "keyEncipherment", myClass.m_keyEncipherment, "");
    parseAttribute(element, "nonRepudiation", myClass.m_nonRepudiation, "");
    parseAttribute(element, "type", myClass.m_type, "optional");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_line : public XFA_BaseNode
{
public:

    const HAND* getHand() const {  return m_hand.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const SLOPE* getSlope() const {  return m_slope.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_edge* getEdge() const {  return m_edge.getValue(); }

    static std::optional<XFA_line> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<HAND> m_hand;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<SLOPE> m_slope;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_edge> m_edge;
};

std::optional<XFA_line> XFA_line::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_line myClass;

    // load attributes
    parseAttribute(element, "hand", myClass.m_hand, "even");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "slope", myClass.m_slope, "\\");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "edge", myClass.m_edge);
    return myClass;
}


class XFA_linear : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const TYPE1* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_color* getColor() const {  return m_color.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }

    static std::optional<XFA_linear> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<TYPE1> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_color> m_color;
    XFA_Node<XFA_extras> m_extras;
};

std::optional<XFA_linear> XFA_linear::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_linear myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "type", myClass.m_type, "toRight");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "color", myClass.m_color);
    parseItem(element, "extras", myClass.m_extras);
    return myClass;
}


class XFA_lockDocument : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const TYPE* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_lockDocument> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<TYPE> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_lockDocument> XFA_lockDocument::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_lockDocument myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "type", myClass.m_type, "optional");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_manifest : public XFA_BaseNode
{
public:

    const ACTION* getAction() const {  return m_action.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const std::vector<XFA_Node<XFA_ref>>& getRef() const {  return m_ref; }

    static std::optional<XFA_manifest> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<ACTION> m_action;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
    std::vector<XFA_Node<XFA_ref>> m_ref;
};

std::optional<XFA_manifest> XFA_manifest::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_manifest myClass;

    // load attributes
    parseAttribute(element, "action", myClass.m_action, "include");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "ref", myClass.m_ref);
    return myClass;
}


class XFA_margin : public XFA_BaseNode
{
public:

    const XFA_Measurement* getBottomInset() const {  return m_bottomInset.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const XFA_Measurement* getLeftInset() const {  return m_leftInset.getValue(); }
    const XFA_Measurement* getRightInset() const {  return m_rightInset.getValue(); }
    const XFA_Measurement* getTopInset() const {  return m_topInset.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }

    static std::optional<XFA_margin> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<XFA_Measurement> m_bottomInset;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<XFA_Measurement> m_leftInset;
    XFA_Attribute<XFA_Measurement> m_rightInset;
    XFA_Attribute<XFA_Measurement> m_topInset;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
};

std::optional<XFA_margin> XFA_margin::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_margin myClass;

    // load attributes
    parseAttribute(element, "bottomInset", myClass.m_bottomInset, "0in");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "leftInset", myClass.m_leftInset, "0in");
    parseAttribute(element, "rightInset", myClass.m_rightInset, "0in");
    parseAttribute(element, "topInset", myClass.m_topInset, "0in");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    return myClass;
}


class XFA_mdp : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const PERMISSIONS* getPermissions() const {  return m_permissions.getValue(); }
    const SIGNATURETYPE* getSignatureType() const {  return m_signatureType.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    static std::optional<XFA_mdp> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<PERMISSIONS> m_permissions;
    XFA_Attribute<SIGNATURETYPE> m_signatureType;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
};

std::optional<XFA_mdp> XFA_mdp::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_mdp myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "permissions", myClass.m_permissions, "2");
    parseAttribute(element, "signatureType", myClass.m_signatureType, "filler");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_medium : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getImagingBBox() const {  return m_imagingBBox.getValue(); }
    const XFA_Measurement* getLong() const {  return m_long.getValue(); }
    const ORIENTATION* getOrientation() const {  return m_orientation.getValue(); }
    const XFA_Measurement* getShort() const {  return m_short.getValue(); }
    const QString* getStock() const {  return m_stock.getValue(); }
    const TRAYIN* getTrayIn() const {  return m_trayIn.getValue(); }
    const TRAYOUT* getTrayOut() const {  return m_trayOut.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    static std::optional<XFA_medium> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_imagingBBox;
    XFA_Attribute<XFA_Measurement> m_long;
    XFA_Attribute<ORIENTATION> m_orientation;
    XFA_Attribute<XFA_Measurement> m_short;
    XFA_Attribute<QString> m_stock;
    XFA_Attribute<TRAYIN> m_trayIn;
    XFA_Attribute<TRAYOUT> m_trayOut;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
};

std::optional<XFA_medium> XFA_medium::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_medium myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "imagingBBox", myClass.m_imagingBBox, "");
    parseAttribute(element, "long", myClass.m_long, "0in");
    parseAttribute(element, "orientation", myClass.m_orientation, "portrait");
    parseAttribute(element, "short", myClass.m_short, "0in");
    parseAttribute(element, "stock", myClass.m_stock, "");
    parseAttribute(element, "trayIn", myClass.m_trayIn, "auto");
    parseAttribute(element, "trayOut", myClass.m_trayOut, "auto");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_message : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const std::vector<XFA_Node<XFA_text>>& getText() const {  return m_text; }

    static std::optional<XFA_message> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    std::vector<XFA_Node<XFA_text>> m_text;
};

std::optional<XFA_message> XFA_message::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_message myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "text", myClass.m_text);
    return myClass;
}


class XFA_numericEdit : public XFA_BaseNode
{
public:

    const HSCROLLPOLICY* getHScrollPolicy() const {  return m_hScrollPolicy.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_border* getBorder() const {  return m_border.getValue(); }
    const XFA_comb* getComb() const {  return m_comb.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_margin* getMargin() const {  return m_margin.getValue(); }

    static std::optional<XFA_numericEdit> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<HSCROLLPOLICY> m_hScrollPolicy;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_border> m_border;
    XFA_Node<XFA_comb> m_comb;
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_margin> m_margin;
};

std::optional<XFA_numericEdit> XFA_numericEdit::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_numericEdit myClass;

    // load attributes
    parseAttribute(element, "hScrollPolicy", myClass.m_hScrollPolicy, "auto");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "border", myClass.m_border);
    parseItem(element, "comb", myClass.m_comb);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "margin", myClass.m_margin);
    return myClass;
}


class XFA_occur : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const PDFInteger* getInitial() const {  return m_initial.getValue(); }
    const PDFInteger* getMax() const {  return m_max.getValue(); }
    const PDFInteger* getMin() const {  return m_min.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }

    static std::optional<XFA_occur> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<PDFInteger> m_initial;
    XFA_Attribute<PDFInteger> m_max;
    XFA_Attribute<PDFInteger> m_min;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
};

std::optional<XFA_occur> XFA_occur::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_occur myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "initial", myClass.m_initial, "1");
    parseAttribute(element, "max", myClass.m_max, "1");
    parseAttribute(element, "min", myClass.m_min, "1");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    return myClass;
}


class XFA_oid : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_oid> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_oid> XFA_oid::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_oid myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_oids : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const TYPE* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const std::vector<XFA_Node<XFA_oid>>& getOid() const {  return m_oid; }

    static std::optional<XFA_oids> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<TYPE> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    std::vector<XFA_Node<XFA_oid>> m_oid;
};

std::optional<XFA_oids> XFA_oids::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_oids myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "type", myClass.m_type, "optional");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "oid", myClass.m_oid);
    return myClass;
}


class XFA_overflow : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getLeader() const {  return m_leader.getValue(); }
    const QString* getTarget() const {  return m_target.getValue(); }
    const QString* getTrailer() const {  return m_trailer.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    static std::optional<XFA_overflow> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_leader;
    XFA_Attribute<QString> m_target;
    XFA_Attribute<QString> m_trailer;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
};

std::optional<XFA_overflow> XFA_overflow::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_overflow myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "leader", myClass.m_leader, "");
    parseAttribute(element, "target", myClass.m_target, "");
    parseAttribute(element, "trailer", myClass.m_trailer, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_pageArea : public XFA_BaseNode
{
public:

    const BLANKORNOTBLANK* getBlankOrNotBlank() const {  return m_blankOrNotBlank.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const PDFInteger* getInitialNumber() const {  return m_initialNumber.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const PDFInteger* getNumbered() const {  return m_numbered.getValue(); }
    const ODDOREVEN* getOddOrEven() const {  return m_oddOrEven.getValue(); }
    const PAGEPOSITION* getPagePosition() const {  return m_pagePosition.getValue(); }
    const QString* getRelevant() const {  return m_relevant.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_desc* getDesc() const {  return m_desc.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_medium* getMedium() const {  return m_medium.getValue(); }
    const XFA_occur* getOccur() const {  return m_occur.getValue(); }
    const std::vector<XFA_Node<XFA_area>>& getArea() const {  return m_area; }
    const std::vector<XFA_Node<XFA_contentArea>>& getContentArea() const {  return m_contentArea; }
    const std::vector<XFA_Node<XFA_draw>>& getDraw() const {  return m_draw; }
    const std::vector<XFA_Node<XFA_exclGroup>>& getExclGroup() const {  return m_exclGroup; }
    const std::vector<XFA_Node<XFA_field>>& getField() const {  return m_field; }
    const std::vector<XFA_Node<XFA_subform>>& getSubform() const {  return m_subform; }

    static std::optional<XFA_pageArea> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<BLANKORNOTBLANK> m_blankOrNotBlank;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<PDFInteger> m_initialNumber;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<PDFInteger> m_numbered;
    XFA_Attribute<ODDOREVEN> m_oddOrEven;
    XFA_Attribute<PAGEPOSITION> m_pagePosition;
    XFA_Attribute<QString> m_relevant;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_desc> m_desc;
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_medium> m_medium;
    XFA_Node<XFA_occur> m_occur;
    std::vector<XFA_Node<XFA_area>> m_area;
    std::vector<XFA_Node<XFA_contentArea>> m_contentArea;
    std::vector<XFA_Node<XFA_draw>> m_draw;
    std::vector<XFA_Node<XFA_exclGroup>> m_exclGroup;
    std::vector<XFA_Node<XFA_field>> m_field;
    std::vector<XFA_Node<XFA_subform>> m_subform;
};

std::optional<XFA_pageArea> XFA_pageArea::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_pageArea myClass;

    // load attributes
    parseAttribute(element, "blankOrNotBlank", myClass.m_blankOrNotBlank, "any");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "initialNumber", myClass.m_initialNumber, "1");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "numbered", myClass.m_numbered, "1");
    parseAttribute(element, "oddOrEven", myClass.m_oddOrEven, "any");
    parseAttribute(element, "pagePosition", myClass.m_pagePosition, "any");
    parseAttribute(element, "relevant", myClass.m_relevant, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "desc", myClass.m_desc);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "medium", myClass.m_medium);
    parseItem(element, "occur", myClass.m_occur);
    parseItem(element, "area", myClass.m_area);
    parseItem(element, "contentArea", myClass.m_contentArea);
    parseItem(element, "draw", myClass.m_draw);
    parseItem(element, "exclGroup", myClass.m_exclGroup);
    parseItem(element, "field", myClass.m_field);
    parseItem(element, "subform", myClass.m_subform);
    return myClass;
}


class XFA_pageSet : public XFA_BaseNode
{
public:

    const DUPLEXIMPOSITION* getDuplexImposition() const {  return m_duplexImposition.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const RELATION* getRelation() const {  return m_relation.getValue(); }
    const QString* getRelevant() const {  return m_relevant.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_occur* getOccur() const {  return m_occur.getValue(); }
    const std::vector<XFA_Node<XFA_pageArea>>& getPageArea() const {  return m_pageArea; }
    const std::vector<XFA_Node<XFA_pageSet>>& getPageSet() const {  return m_pageSet; }

    static std::optional<XFA_pageSet> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<DUPLEXIMPOSITION> m_duplexImposition;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<RELATION> m_relation;
    XFA_Attribute<QString> m_relevant;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_occur> m_occur;
    std::vector<XFA_Node<XFA_pageArea>> m_pageArea;
    std::vector<XFA_Node<XFA_pageSet>> m_pageSet;
};

std::optional<XFA_pageSet> XFA_pageSet::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_pageSet myClass;

    // load attributes
    parseAttribute(element, "duplexImposition", myClass.m_duplexImposition, "longEdge");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "relation", myClass.m_relation, "orderedOccurrence");
    parseAttribute(element, "relevant", myClass.m_relevant, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "occur", myClass.m_occur);
    parseItem(element, "pageArea", myClass.m_pageArea);
    parseItem(element, "pageSet", myClass.m_pageSet);
    return myClass;
}


class XFA_para : public XFA_BaseNode
{
public:

    const HALIGN* getHAlign() const {  return m_hAlign.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const XFA_Measurement* getLineHeight() const {  return m_lineHeight.getValue(); }
    const XFA_Measurement* getMarginLeft() const {  return m_marginLeft.getValue(); }
    const XFA_Measurement* getMarginRight() const {  return m_marginRight.getValue(); }
    const PDFInteger* getOrphans() const {  return m_orphans.getValue(); }
    const QString* getPreserve() const {  return m_preserve.getValue(); }
    const XFA_Measurement* getRadixOffset() const {  return m_radixOffset.getValue(); }
    const XFA_Measurement* getSpaceAbove() const {  return m_spaceAbove.getValue(); }
    const XFA_Measurement* getSpaceBelow() const {  return m_spaceBelow.getValue(); }
    const QString* getTabDefault() const {  return m_tabDefault.getValue(); }
    const QString* getTabStops() const {  return m_tabStops.getValue(); }
    const XFA_Measurement* getTextIndent() const {  return m_textIndent.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }
    const VALIGN* getVAlign() const {  return m_vAlign.getValue(); }
    const PDFInteger* getWidows() const {  return m_widows.getValue(); }

    const XFA_hyphenation* getHyphenation() const {  return m_hyphenation.getValue(); }

    static std::optional<XFA_para> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<HALIGN> m_hAlign;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<XFA_Measurement> m_lineHeight;
    XFA_Attribute<XFA_Measurement> m_marginLeft;
    XFA_Attribute<XFA_Measurement> m_marginRight;
    XFA_Attribute<PDFInteger> m_orphans;
    XFA_Attribute<QString> m_preserve;
    XFA_Attribute<XFA_Measurement> m_radixOffset;
    XFA_Attribute<XFA_Measurement> m_spaceAbove;
    XFA_Attribute<XFA_Measurement> m_spaceBelow;
    XFA_Attribute<QString> m_tabDefault;
    XFA_Attribute<QString> m_tabStops;
    XFA_Attribute<XFA_Measurement> m_textIndent;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;
    XFA_Attribute<VALIGN> m_vAlign;
    XFA_Attribute<PDFInteger> m_widows;

    /* subnodes */
    XFA_Node<XFA_hyphenation> m_hyphenation;
};

std::optional<XFA_para> XFA_para::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_para myClass;

    // load attributes
    parseAttribute(element, "hAlign", myClass.m_hAlign, "left");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "lineHeight", myClass.m_lineHeight, "0pt");
    parseAttribute(element, "marginLeft", myClass.m_marginLeft, "0in");
    parseAttribute(element, "marginRight", myClass.m_marginRight, "0in");
    parseAttribute(element, "orphans", myClass.m_orphans, "0");
    parseAttribute(element, "preserve", myClass.m_preserve, "");
    parseAttribute(element, "radixOffset", myClass.m_radixOffset, "0in");
    parseAttribute(element, "spaceAbove", myClass.m_spaceAbove, "0in");
    parseAttribute(element, "spaceBelow", myClass.m_spaceBelow, "0in");
    parseAttribute(element, "tabDefault", myClass.m_tabDefault, "");
    parseAttribute(element, "tabStops", myClass.m_tabStops, "");
    parseAttribute(element, "textIndent", myClass.m_textIndent, "0in");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");
    parseAttribute(element, "vAlign", myClass.m_vAlign, "top");
    parseAttribute(element, "widows", myClass.m_widows, "0");

    // load items
    parseItem(element, "hyphenation", myClass.m_hyphenation);
    return myClass;
}


class XFA_passwordEdit : public XFA_BaseNode
{
public:

    const HSCROLLPOLICY* getHScrollPolicy() const {  return m_hScrollPolicy.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getPasswordChar() const {  return m_passwordChar.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_border* getBorder() const {  return m_border.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_margin* getMargin() const {  return m_margin.getValue(); }

    static std::optional<XFA_passwordEdit> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<HSCROLLPOLICY> m_hScrollPolicy;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_passwordChar;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_border> m_border;
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_margin> m_margin;
};

std::optional<XFA_passwordEdit> XFA_passwordEdit::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_passwordEdit myClass;

    // load attributes
    parseAttribute(element, "hScrollPolicy", myClass.m_hScrollPolicy, "auto");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "passwordChar", myClass.m_passwordChar, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "border", myClass.m_border);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "margin", myClass.m_margin);
    return myClass;
}


class XFA_pattern : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const TYPE2* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_color* getColor() const {  return m_color.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }

    static std::optional<XFA_pattern> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<TYPE2> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_color> m_color;
    XFA_Node<XFA_extras> m_extras;
};

std::optional<XFA_pattern> XFA_pattern::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_pattern myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "type", myClass.m_type, "crossHatch");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "color", myClass.m_color);
    parseItem(element, "extras", myClass.m_extras);
    return myClass;
}


class XFA_picture : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_picture> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_picture> XFA_picture::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_picture myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_proto : public XFA_BaseNode
{
public:


    const std::vector<XFA_Node<XFA_appearanceFilter>>& getAppearanceFilter() const {  return m_appearanceFilter; }
    const std::vector<XFA_Node<XFA_arc>>& getArc() const {  return m_arc; }
    const std::vector<XFA_Node<XFA_area>>& getArea() const {  return m_area; }
    const std::vector<XFA_Node<XFA_assist>>& getAssist() const {  return m_assist; }
    const std::vector<XFA_Node<XFA_barcode>>& getBarcode() const {  return m_barcode; }
    const std::vector<XFA_Node<XFA_bindItems>>& getBindItems() const {  return m_bindItems; }
    const std::vector<XFA_Node<XFA_bookend>>& getBookend() const {  return m_bookend; }
    const std::vector<XFA_Node<XFA_boolean>>& getBoolean() const {  return m_boolean; }
    const std::vector<XFA_Node<XFA_border>>& getBorder() const {  return m_border; }
    const std::vector<XFA_Node<XFA_break>>& getBreak() const {  return m_break; }
    const std::vector<XFA_Node<XFA_breakAfter>>& getBreakAfter() const {  return m_breakAfter; }
    const std::vector<XFA_Node<XFA_breakBefore>>& getBreakBefore() const {  return m_breakBefore; }
    const std::vector<XFA_Node<XFA_button>>& getButton() const {  return m_button; }
    const std::vector<XFA_Node<XFA_calculate>>& getCalculate() const {  return m_calculate; }
    const std::vector<XFA_Node<XFA_caption>>& getCaption() const {  return m_caption; }
    const std::vector<XFA_Node<XFA_certificate>>& getCertificate() const {  return m_certificate; }
    const std::vector<XFA_Node<XFA_certificates>>& getCertificates() const {  return m_certificates; }
    const std::vector<XFA_Node<XFA_checkButton>>& getCheckButton() const {  return m_checkButton; }
    const std::vector<XFA_Node<XFA_choiceList>>& getChoiceList() const {  return m_choiceList; }
    const std::vector<XFA_Node<XFA_color>>& getColor() const {  return m_color; }
    const std::vector<XFA_Node<XFA_comb>>& getComb() const {  return m_comb; }
    const std::vector<XFA_Node<XFA_connect>>& getConnect() const {  return m_connect; }
    const std::vector<XFA_Node<XFA_contentArea>>& getContentArea() const {  return m_contentArea; }
    const std::vector<XFA_Node<XFA_corner>>& getCorner() const {  return m_corner; }
    const std::vector<XFA_Node<XFA_date>>& getDate() const {  return m_date; }
    const std::vector<XFA_Node<XFA_dateTime>>& getDateTime() const {  return m_dateTime; }
    const std::vector<XFA_Node<XFA_dateTimeEdit>>& getDateTimeEdit() const {  return m_dateTimeEdit; }
    const std::vector<XFA_Node<XFA_decimal>>& getDecimal() const {  return m_decimal; }
    const std::vector<XFA_Node<XFA_defaultUi>>& getDefaultUi() const {  return m_defaultUi; }
    const std::vector<XFA_Node<XFA_desc>>& getDesc() const {  return m_desc; }
    const std::vector<XFA_Node<XFA_digestMethod>>& getDigestMethod() const {  return m_digestMethod; }
    const std::vector<XFA_Node<XFA_digestMethods>>& getDigestMethods() const {  return m_digestMethods; }
    const std::vector<XFA_Node<XFA_draw>>& getDraw() const {  return m_draw; }
    const std::vector<XFA_Node<XFA_edge>>& getEdge() const {  return m_edge; }
    const std::vector<XFA_Node<XFA_encoding>>& getEncoding() const {  return m_encoding; }
    const std::vector<XFA_Node<XFA_encodings>>& getEncodings() const {  return m_encodings; }
    const std::vector<XFA_Node<XFA_encrypt>>& getEncrypt() const {  return m_encrypt; }
    const std::vector<XFA_Node<XFA_encryptData>>& getEncryptData() const {  return m_encryptData; }
    const std::vector<XFA_Node<XFA_encryption>>& getEncryption() const {  return m_encryption; }
    const std::vector<XFA_Node<XFA_encryptionMethod>>& getEncryptionMethod() const {  return m_encryptionMethod; }
    const std::vector<XFA_Node<XFA_encryptionMethods>>& getEncryptionMethods() const {  return m_encryptionMethods; }
    const std::vector<XFA_Node<XFA_event>>& getEvent() const {  return m_event; }
    const std::vector<XFA_Node<XFA_exData>>& getExData() const {  return m_exData; }
    const std::vector<XFA_Node<XFA_exObject>>& getExObject() const {  return m_exObject; }
    const std::vector<XFA_Node<XFA_exclGroup>>& getExclGroup() const {  return m_exclGroup; }
    const std::vector<XFA_Node<XFA_execute>>& getExecute() const {  return m_execute; }
    const std::vector<XFA_Node<XFA_extras>>& getExtras() const {  return m_extras; }
    const std::vector<XFA_Node<XFA_field>>& getField() const {  return m_field; }
    const std::vector<XFA_Node<XFA_fill>>& getFill() const {  return m_fill; }
    const std::vector<XFA_Node<XFA_filter>>& getFilter() const {  return m_filter; }
    const std::vector<XFA_Node<XFA_float>>& getFloat() const {  return m_float; }
    const std::vector<XFA_Node<XFA_font>>& getFont() const {  return m_font; }
    const std::vector<XFA_Node<XFA_format>>& getFormat() const {  return m_format; }
    const std::vector<XFA_Node<XFA_handler>>& getHandler() const {  return m_handler; }
    const std::vector<XFA_Node<XFA_hyphenation>>& getHyphenation() const {  return m_hyphenation; }
    const std::vector<XFA_Node<XFA_image>>& getImage() const {  return m_image; }
    const std::vector<XFA_Node<XFA_imageEdit>>& getImageEdit() const {  return m_imageEdit; }
    const std::vector<XFA_Node<XFA_integer>>& getInteger() const {  return m_integer; }
    const std::vector<XFA_Node<XFA_issuers>>& getIssuers() const {  return m_issuers; }
    const std::vector<XFA_Node<XFA_items>>& getItems() const {  return m_items; }
    const std::vector<XFA_Node<XFA_keep>>& getKeep() const {  return m_keep; }
    const std::vector<XFA_Node<XFA_keyUsage>>& getKeyUsage() const {  return m_keyUsage; }
    const std::vector<XFA_Node<XFA_line>>& getLine() const {  return m_line; }
    const std::vector<XFA_Node<XFA_linear>>& getLinear() const {  return m_linear; }
    const std::vector<XFA_Node<XFA_lockDocument>>& getLockDocument() const {  return m_lockDocument; }
    const std::vector<XFA_Node<XFA_manifest>>& getManifest() const {  return m_manifest; }
    const std::vector<XFA_Node<XFA_margin>>& getMargin() const {  return m_margin; }
    const std::vector<XFA_Node<XFA_mdp>>& getMdp() const {  return m_mdp; }
    const std::vector<XFA_Node<XFA_medium>>& getMedium() const {  return m_medium; }
    const std::vector<XFA_Node<XFA_message>>& getMessage() const {  return m_message; }
    const std::vector<XFA_Node<XFA_numericEdit>>& getNumericEdit() const {  return m_numericEdit; }
    const std::vector<XFA_Node<XFA_occur>>& getOccur() const {  return m_occur; }
    const std::vector<XFA_Node<XFA_oid>>& getOid() const {  return m_oid; }
    const std::vector<XFA_Node<XFA_oids>>& getOids() const {  return m_oids; }
    const std::vector<XFA_Node<XFA_overflow>>& getOverflow() const {  return m_overflow; }
    const std::vector<XFA_Node<XFA_pageArea>>& getPageArea() const {  return m_pageArea; }
    const std::vector<XFA_Node<XFA_pageSet>>& getPageSet() const {  return m_pageSet; }
    const std::vector<XFA_Node<XFA_para>>& getPara() const {  return m_para; }
    const std::vector<XFA_Node<XFA_passwordEdit>>& getPasswordEdit() const {  return m_passwordEdit; }
    const std::vector<XFA_Node<XFA_pattern>>& getPattern() const {  return m_pattern; }
    const std::vector<XFA_Node<XFA_picture>>& getPicture() const {  return m_picture; }
    const std::vector<XFA_Node<XFA_radial>>& getRadial() const {  return m_radial; }
    const std::vector<XFA_Node<XFA_reason>>& getReason() const {  return m_reason; }
    const std::vector<XFA_Node<XFA_reasons>>& getReasons() const {  return m_reasons; }
    const std::vector<XFA_Node<XFA_rectangle>>& getRectangle() const {  return m_rectangle; }
    const std::vector<XFA_Node<XFA_ref>>& getRef() const {  return m_ref; }
    const std::vector<XFA_Node<XFA_script>>& getScript() const {  return m_script; }
    const std::vector<XFA_Node<XFA_setProperty>>& getSetProperty() const {  return m_setProperty; }
    const std::vector<XFA_Node<XFA_signData>>& getSignData() const {  return m_signData; }
    const std::vector<XFA_Node<XFA_signature>>& getSignature() const {  return m_signature; }
    const std::vector<XFA_Node<XFA_signing>>& getSigning() const {  return m_signing; }
    const std::vector<XFA_Node<XFA_solid>>& getSolid() const {  return m_solid; }
    const std::vector<XFA_Node<XFA_speak>>& getSpeak() const {  return m_speak; }
    const std::vector<XFA_Node<XFA_stipple>>& getStipple() const {  return m_stipple; }
    const std::vector<XFA_Node<XFA_subform>>& getSubform() const {  return m_subform; }
    const std::vector<XFA_Node<XFA_subformSet>>& getSubformSet() const {  return m_subformSet; }
    const std::vector<XFA_Node<XFA_subjectDN>>& getSubjectDN() const {  return m_subjectDN; }
    const std::vector<XFA_Node<XFA_subjectDNs>>& getSubjectDNs() const {  return m_subjectDNs; }
    const std::vector<XFA_Node<XFA_submit>>& getSubmit() const {  return m_submit; }
    const std::vector<XFA_Node<XFA_text>>& getText() const {  return m_text; }
    const std::vector<XFA_Node<XFA_textEdit>>& getTextEdit() const {  return m_textEdit; }
    const std::vector<XFA_Node<XFA_time>>& getTime() const {  return m_time; }
    const std::vector<XFA_Node<XFA_timeStamp>>& getTimeStamp() const {  return m_timeStamp; }
    const std::vector<XFA_Node<XFA_toolTip>>& getToolTip() const {  return m_toolTip; }
    const std::vector<XFA_Node<XFA_traversal>>& getTraversal() const {  return m_traversal; }
    const std::vector<XFA_Node<XFA_traverse>>& getTraverse() const {  return m_traverse; }
    const std::vector<XFA_Node<XFA_ui>>& getUi() const {  return m_ui; }
    const std::vector<XFA_Node<XFA_validate>>& getValidate() const {  return m_validate; }
    const std::vector<XFA_Node<XFA_value>>& getValue() const {  return m_value; }
    const std::vector<XFA_Node<XFA_variables>>& getVariables() const {  return m_variables; }

    static std::optional<XFA_proto> parse(const QDomElement& element);

private:
    /* properties */

    /* subnodes */
    std::vector<XFA_Node<XFA_appearanceFilter>> m_appearanceFilter;
    std::vector<XFA_Node<XFA_arc>> m_arc;
    std::vector<XFA_Node<XFA_area>> m_area;
    std::vector<XFA_Node<XFA_assist>> m_assist;
    std::vector<XFA_Node<XFA_barcode>> m_barcode;
    std::vector<XFA_Node<XFA_bindItems>> m_bindItems;
    std::vector<XFA_Node<XFA_bookend>> m_bookend;
    std::vector<XFA_Node<XFA_boolean>> m_boolean;
    std::vector<XFA_Node<XFA_border>> m_border;
    std::vector<XFA_Node<XFA_break>> m_break;
    std::vector<XFA_Node<XFA_breakAfter>> m_breakAfter;
    std::vector<XFA_Node<XFA_breakBefore>> m_breakBefore;
    std::vector<XFA_Node<XFA_button>> m_button;
    std::vector<XFA_Node<XFA_calculate>> m_calculate;
    std::vector<XFA_Node<XFA_caption>> m_caption;
    std::vector<XFA_Node<XFA_certificate>> m_certificate;
    std::vector<XFA_Node<XFA_certificates>> m_certificates;
    std::vector<XFA_Node<XFA_checkButton>> m_checkButton;
    std::vector<XFA_Node<XFA_choiceList>> m_choiceList;
    std::vector<XFA_Node<XFA_color>> m_color;
    std::vector<XFA_Node<XFA_comb>> m_comb;
    std::vector<XFA_Node<XFA_connect>> m_connect;
    std::vector<XFA_Node<XFA_contentArea>> m_contentArea;
    std::vector<XFA_Node<XFA_corner>> m_corner;
    std::vector<XFA_Node<XFA_date>> m_date;
    std::vector<XFA_Node<XFA_dateTime>> m_dateTime;
    std::vector<XFA_Node<XFA_dateTimeEdit>> m_dateTimeEdit;
    std::vector<XFA_Node<XFA_decimal>> m_decimal;
    std::vector<XFA_Node<XFA_defaultUi>> m_defaultUi;
    std::vector<XFA_Node<XFA_desc>> m_desc;
    std::vector<XFA_Node<XFA_digestMethod>> m_digestMethod;
    std::vector<XFA_Node<XFA_digestMethods>> m_digestMethods;
    std::vector<XFA_Node<XFA_draw>> m_draw;
    std::vector<XFA_Node<XFA_edge>> m_edge;
    std::vector<XFA_Node<XFA_encoding>> m_encoding;
    std::vector<XFA_Node<XFA_encodings>> m_encodings;
    std::vector<XFA_Node<XFA_encrypt>> m_encrypt;
    std::vector<XFA_Node<XFA_encryptData>> m_encryptData;
    std::vector<XFA_Node<XFA_encryption>> m_encryption;
    std::vector<XFA_Node<XFA_encryptionMethod>> m_encryptionMethod;
    std::vector<XFA_Node<XFA_encryptionMethods>> m_encryptionMethods;
    std::vector<XFA_Node<XFA_event>> m_event;
    std::vector<XFA_Node<XFA_exData>> m_exData;
    std::vector<XFA_Node<XFA_exObject>> m_exObject;
    std::vector<XFA_Node<XFA_exclGroup>> m_exclGroup;
    std::vector<XFA_Node<XFA_execute>> m_execute;
    std::vector<XFA_Node<XFA_extras>> m_extras;
    std::vector<XFA_Node<XFA_field>> m_field;
    std::vector<XFA_Node<XFA_fill>> m_fill;
    std::vector<XFA_Node<XFA_filter>> m_filter;
    std::vector<XFA_Node<XFA_float>> m_float;
    std::vector<XFA_Node<XFA_font>> m_font;
    std::vector<XFA_Node<XFA_format>> m_format;
    std::vector<XFA_Node<XFA_handler>> m_handler;
    std::vector<XFA_Node<XFA_hyphenation>> m_hyphenation;
    std::vector<XFA_Node<XFA_image>> m_image;
    std::vector<XFA_Node<XFA_imageEdit>> m_imageEdit;
    std::vector<XFA_Node<XFA_integer>> m_integer;
    std::vector<XFA_Node<XFA_issuers>> m_issuers;
    std::vector<XFA_Node<XFA_items>> m_items;
    std::vector<XFA_Node<XFA_keep>> m_keep;
    std::vector<XFA_Node<XFA_keyUsage>> m_keyUsage;
    std::vector<XFA_Node<XFA_line>> m_line;
    std::vector<XFA_Node<XFA_linear>> m_linear;
    std::vector<XFA_Node<XFA_lockDocument>> m_lockDocument;
    std::vector<XFA_Node<XFA_manifest>> m_manifest;
    std::vector<XFA_Node<XFA_margin>> m_margin;
    std::vector<XFA_Node<XFA_mdp>> m_mdp;
    std::vector<XFA_Node<XFA_medium>> m_medium;
    std::vector<XFA_Node<XFA_message>> m_message;
    std::vector<XFA_Node<XFA_numericEdit>> m_numericEdit;
    std::vector<XFA_Node<XFA_occur>> m_occur;
    std::vector<XFA_Node<XFA_oid>> m_oid;
    std::vector<XFA_Node<XFA_oids>> m_oids;
    std::vector<XFA_Node<XFA_overflow>> m_overflow;
    std::vector<XFA_Node<XFA_pageArea>> m_pageArea;
    std::vector<XFA_Node<XFA_pageSet>> m_pageSet;
    std::vector<XFA_Node<XFA_para>> m_para;
    std::vector<XFA_Node<XFA_passwordEdit>> m_passwordEdit;
    std::vector<XFA_Node<XFA_pattern>> m_pattern;
    std::vector<XFA_Node<XFA_picture>> m_picture;
    std::vector<XFA_Node<XFA_radial>> m_radial;
    std::vector<XFA_Node<XFA_reason>> m_reason;
    std::vector<XFA_Node<XFA_reasons>> m_reasons;
    std::vector<XFA_Node<XFA_rectangle>> m_rectangle;
    std::vector<XFA_Node<XFA_ref>> m_ref;
    std::vector<XFA_Node<XFA_script>> m_script;
    std::vector<XFA_Node<XFA_setProperty>> m_setProperty;
    std::vector<XFA_Node<XFA_signData>> m_signData;
    std::vector<XFA_Node<XFA_signature>> m_signature;
    std::vector<XFA_Node<XFA_signing>> m_signing;
    std::vector<XFA_Node<XFA_solid>> m_solid;
    std::vector<XFA_Node<XFA_speak>> m_speak;
    std::vector<XFA_Node<XFA_stipple>> m_stipple;
    std::vector<XFA_Node<XFA_subform>> m_subform;
    std::vector<XFA_Node<XFA_subformSet>> m_subformSet;
    std::vector<XFA_Node<XFA_subjectDN>> m_subjectDN;
    std::vector<XFA_Node<XFA_subjectDNs>> m_subjectDNs;
    std::vector<XFA_Node<XFA_submit>> m_submit;
    std::vector<XFA_Node<XFA_text>> m_text;
    std::vector<XFA_Node<XFA_textEdit>> m_textEdit;
    std::vector<XFA_Node<XFA_time>> m_time;
    std::vector<XFA_Node<XFA_timeStamp>> m_timeStamp;
    std::vector<XFA_Node<XFA_toolTip>> m_toolTip;
    std::vector<XFA_Node<XFA_traversal>> m_traversal;
    std::vector<XFA_Node<XFA_traverse>> m_traverse;
    std::vector<XFA_Node<XFA_ui>> m_ui;
    std::vector<XFA_Node<XFA_validate>> m_validate;
    std::vector<XFA_Node<XFA_value>> m_value;
    std::vector<XFA_Node<XFA_variables>> m_variables;
};

std::optional<XFA_proto> XFA_proto::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_proto myClass;

    // load attributes

    // load items
    parseItem(element, "appearanceFilter", myClass.m_appearanceFilter);
    parseItem(element, "arc", myClass.m_arc);
    parseItem(element, "area", myClass.m_area);
    parseItem(element, "assist", myClass.m_assist);
    parseItem(element, "barcode", myClass.m_barcode);
    parseItem(element, "bindItems", myClass.m_bindItems);
    parseItem(element, "bookend", myClass.m_bookend);
    parseItem(element, "boolean", myClass.m_boolean);
    parseItem(element, "border", myClass.m_border);
    parseItem(element, "break", myClass.m_break);
    parseItem(element, "breakAfter", myClass.m_breakAfter);
    parseItem(element, "breakBefore", myClass.m_breakBefore);
    parseItem(element, "button", myClass.m_button);
    parseItem(element, "calculate", myClass.m_calculate);
    parseItem(element, "caption", myClass.m_caption);
    parseItem(element, "certificate", myClass.m_certificate);
    parseItem(element, "certificates", myClass.m_certificates);
    parseItem(element, "checkButton", myClass.m_checkButton);
    parseItem(element, "choiceList", myClass.m_choiceList);
    parseItem(element, "color", myClass.m_color);
    parseItem(element, "comb", myClass.m_comb);
    parseItem(element, "connect", myClass.m_connect);
    parseItem(element, "contentArea", myClass.m_contentArea);
    parseItem(element, "corner", myClass.m_corner);
    parseItem(element, "date", myClass.m_date);
    parseItem(element, "dateTime", myClass.m_dateTime);
    parseItem(element, "dateTimeEdit", myClass.m_dateTimeEdit);
    parseItem(element, "decimal", myClass.m_decimal);
    parseItem(element, "defaultUi", myClass.m_defaultUi);
    parseItem(element, "desc", myClass.m_desc);
    parseItem(element, "digestMethod", myClass.m_digestMethod);
    parseItem(element, "digestMethods", myClass.m_digestMethods);
    parseItem(element, "draw", myClass.m_draw);
    parseItem(element, "edge", myClass.m_edge);
    parseItem(element, "encoding", myClass.m_encoding);
    parseItem(element, "encodings", myClass.m_encodings);
    parseItem(element, "encrypt", myClass.m_encrypt);
    parseItem(element, "encryptData", myClass.m_encryptData);
    parseItem(element, "encryption", myClass.m_encryption);
    parseItem(element, "encryptionMethod", myClass.m_encryptionMethod);
    parseItem(element, "encryptionMethods", myClass.m_encryptionMethods);
    parseItem(element, "event", myClass.m_event);
    parseItem(element, "exData", myClass.m_exData);
    parseItem(element, "exObject", myClass.m_exObject);
    parseItem(element, "exclGroup", myClass.m_exclGroup);
    parseItem(element, "execute", myClass.m_execute);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "field", myClass.m_field);
    parseItem(element, "fill", myClass.m_fill);
    parseItem(element, "filter", myClass.m_filter);
    parseItem(element, "float", myClass.m_float);
    parseItem(element, "font", myClass.m_font);
    parseItem(element, "format", myClass.m_format);
    parseItem(element, "handler", myClass.m_handler);
    parseItem(element, "hyphenation", myClass.m_hyphenation);
    parseItem(element, "image", myClass.m_image);
    parseItem(element, "imageEdit", myClass.m_imageEdit);
    parseItem(element, "integer", myClass.m_integer);
    parseItem(element, "issuers", myClass.m_issuers);
    parseItem(element, "items", myClass.m_items);
    parseItem(element, "keep", myClass.m_keep);
    parseItem(element, "keyUsage", myClass.m_keyUsage);
    parseItem(element, "line", myClass.m_line);
    parseItem(element, "linear", myClass.m_linear);
    parseItem(element, "lockDocument", myClass.m_lockDocument);
    parseItem(element, "manifest", myClass.m_manifest);
    parseItem(element, "margin", myClass.m_margin);
    parseItem(element, "mdp", myClass.m_mdp);
    parseItem(element, "medium", myClass.m_medium);
    parseItem(element, "message", myClass.m_message);
    parseItem(element, "numericEdit", myClass.m_numericEdit);
    parseItem(element, "occur", myClass.m_occur);
    parseItem(element, "oid", myClass.m_oid);
    parseItem(element, "oids", myClass.m_oids);
    parseItem(element, "overflow", myClass.m_overflow);
    parseItem(element, "pageArea", myClass.m_pageArea);
    parseItem(element, "pageSet", myClass.m_pageSet);
    parseItem(element, "para", myClass.m_para);
    parseItem(element, "passwordEdit", myClass.m_passwordEdit);
    parseItem(element, "pattern", myClass.m_pattern);
    parseItem(element, "picture", myClass.m_picture);
    parseItem(element, "radial", myClass.m_radial);
    parseItem(element, "reason", myClass.m_reason);
    parseItem(element, "reasons", myClass.m_reasons);
    parseItem(element, "rectangle", myClass.m_rectangle);
    parseItem(element, "ref", myClass.m_ref);
    parseItem(element, "script", myClass.m_script);
    parseItem(element, "setProperty", myClass.m_setProperty);
    parseItem(element, "signData", myClass.m_signData);
    parseItem(element, "signature", myClass.m_signature);
    parseItem(element, "signing", myClass.m_signing);
    parseItem(element, "solid", myClass.m_solid);
    parseItem(element, "speak", myClass.m_speak);
    parseItem(element, "stipple", myClass.m_stipple);
    parseItem(element, "subform", myClass.m_subform);
    parseItem(element, "subformSet", myClass.m_subformSet);
    parseItem(element, "subjectDN", myClass.m_subjectDN);
    parseItem(element, "subjectDNs", myClass.m_subjectDNs);
    parseItem(element, "submit", myClass.m_submit);
    parseItem(element, "text", myClass.m_text);
    parseItem(element, "textEdit", myClass.m_textEdit);
    parseItem(element, "time", myClass.m_time);
    parseItem(element, "timeStamp", myClass.m_timeStamp);
    parseItem(element, "toolTip", myClass.m_toolTip);
    parseItem(element, "traversal", myClass.m_traversal);
    parseItem(element, "traverse", myClass.m_traverse);
    parseItem(element, "ui", myClass.m_ui);
    parseItem(element, "validate", myClass.m_validate);
    parseItem(element, "value", myClass.m_value);
    parseItem(element, "variables", myClass.m_variables);
    return myClass;
}


class XFA_radial : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const TYPE3* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_color* getColor() const {  return m_color.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }

    static std::optional<XFA_radial> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<TYPE3> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_color> m_color;
    XFA_Node<XFA_extras> m_extras;
};

std::optional<XFA_radial> XFA_radial::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_radial myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "type", myClass.m_type, "toEdge");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "color", myClass.m_color);
    parseItem(element, "extras", myClass.m_extras);
    return myClass;
}


class XFA_reason : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_reason> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_reason> XFA_reason::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_reason myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_reasons : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const TYPE* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const std::vector<XFA_Node<XFA_reason>>& getReason() const {  return m_reason; }

    static std::optional<XFA_reasons> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<TYPE> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    std::vector<XFA_Node<XFA_reason>> m_reason;
};

std::optional<XFA_reasons> XFA_reasons::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_reasons myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "type", myClass.m_type, "optional");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "reason", myClass.m_reason);
    return myClass;
}


class XFA_rectangle : public XFA_BaseNode
{
public:

    const HAND* getHand() const {  return m_hand.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const std::vector<XFA_Node<XFA_corner>>& getCorner() const {  return m_corner; }
    const std::vector<XFA_Node<XFA_edge>>& getEdge() const {  return m_edge; }
    const XFA_fill* getFill() const {  return m_fill.getValue(); }

    static std::optional<XFA_rectangle> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<HAND> m_hand;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    std::vector<XFA_Node<XFA_corner>> m_corner;
    std::vector<XFA_Node<XFA_edge>> m_edge;
    XFA_Node<XFA_fill> m_fill;
};

std::optional<XFA_rectangle> XFA_rectangle::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_rectangle myClass;

    // load attributes
    parseAttribute(element, "hand", myClass.m_hand, "even");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "corner", myClass.m_corner);
    parseItem(element, "edge", myClass.m_edge);
    parseItem(element, "fill", myClass.m_fill);
    return myClass;
}


class XFA_ref : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_ref> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_ref> XFA_ref::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_ref myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_script : public XFA_BaseNode
{
public:

    const QString* getBinding() const {  return m_binding.getValue(); }
    const QString* getContentType() const {  return m_contentType.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const RUNAT* getRunAt() const {  return m_runAt.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_script> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_binding;
    XFA_Attribute<QString> m_contentType;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<RUNAT> m_runAt;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_script> XFA_script::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_script myClass;

    // load attributes
    parseAttribute(element, "binding", myClass.m_binding, "");
    parseAttribute(element, "contentType", myClass.m_contentType, "");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "runAt", myClass.m_runAt, "client");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_setProperty : public XFA_BaseNode
{
public:

    const QString* getConnection() const {  return m_connection.getValue(); }
    const QString* getRef() const {  return m_ref.getValue(); }
    const QString* getTarget() const {  return m_target.getValue(); }


    static std::optional<XFA_setProperty> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_connection;
    XFA_Attribute<QString> m_ref;
    XFA_Attribute<QString> m_target;

    /* subnodes */
};

std::optional<XFA_setProperty> XFA_setProperty::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_setProperty myClass;

    // load attributes
    parseAttribute(element, "connection", myClass.m_connection, "");
    parseAttribute(element, "ref", myClass.m_ref, "");
    parseAttribute(element, "target", myClass.m_target, "");

    // load items
    return myClass;
}


class XFA_signData : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const OPERATION1* getOperation() const {  return m_operation.getValue(); }
    const QString* getRef() const {  return m_ref.getValue(); }
    const QString* getTarget() const {  return m_target.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_filter* getFilter() const {  return m_filter.getValue(); }
    const XFA_manifest* getManifest() const {  return m_manifest.getValue(); }

    static std::optional<XFA_signData> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<OPERATION1> m_operation;
    XFA_Attribute<QString> m_ref;
    XFA_Attribute<QString> m_target;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_filter> m_filter;
    XFA_Node<XFA_manifest> m_manifest;
};

std::optional<XFA_signData> XFA_signData::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_signData myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "operation", myClass.m_operation, "sign");
    parseAttribute(element, "ref", myClass.m_ref, "");
    parseAttribute(element, "target", myClass.m_target, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "filter", myClass.m_filter);
    parseItem(element, "manifest", myClass.m_manifest);
    return myClass;
}


class XFA_signature : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const TYPE4* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_border* getBorder() const {  return m_border.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_filter* getFilter() const {  return m_filter.getValue(); }
    const XFA_manifest* getManifest() const {  return m_manifest.getValue(); }
    const XFA_margin* getMargin() const {  return m_margin.getValue(); }

    static std::optional<XFA_signature> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<TYPE4> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_border> m_border;
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_filter> m_filter;
    XFA_Node<XFA_manifest> m_manifest;
    XFA_Node<XFA_margin> m_margin;
};

std::optional<XFA_signature> XFA_signature::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_signature myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "type", myClass.m_type, "PDF1.3");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "border", myClass.m_border);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "filter", myClass.m_filter);
    parseItem(element, "manifest", myClass.m_manifest);
    parseItem(element, "margin", myClass.m_margin);
    return myClass;
}


class XFA_signing : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const TYPE* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const std::vector<XFA_Node<XFA_certificate>>& getCertificate() const {  return m_certificate; }

    static std::optional<XFA_signing> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<TYPE> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    std::vector<XFA_Node<XFA_certificate>> m_certificate;
};

std::optional<XFA_signing> XFA_signing::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_signing myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "type", myClass.m_type, "optional");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "certificate", myClass.m_certificate);
    return myClass;
}


class XFA_solid : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }

    static std::optional<XFA_solid> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
};

std::optional<XFA_solid> XFA_solid::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_solid myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    return myClass;
}


class XFA_speak : public XFA_BaseNode
{
public:

    const bool* getDisable() const {  return m_disable.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const PRIORITY* getPriority() const {  return m_priority.getValue(); }
    const QString* getRid() const {  return m_rid.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_speak> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<bool> m_disable;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<PRIORITY> m_priority;
    XFA_Attribute<QString> m_rid;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_speak> XFA_speak::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_speak myClass;

    // load attributes
    parseAttribute(element, "disable", myClass.m_disable, "0");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "priority", myClass.m_priority, "custom");
    parseAttribute(element, "rid", myClass.m_rid, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_stipple : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const PDFInteger* getRate() const {  return m_rate.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_color* getColor() const {  return m_color.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }

    static std::optional<XFA_stipple> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<PDFInteger> m_rate;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_color> m_color;
    XFA_Node<XFA_extras> m_extras;
};

std::optional<XFA_stipple> XFA_stipple::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_stipple myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "rate", myClass.m_rate, "50");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "color", myClass.m_color);
    parseItem(element, "extras", myClass.m_extras);
    return myClass;
}


class XFA_subform : public XFA_BaseNode
{
public:

    const ACCESS* getAccess() const {  return m_access.getValue(); }
    const bool* getAllowMacro() const {  return m_allowMacro.getValue(); }
    const ANCHORTYPE* getAnchorType() const {  return m_anchorType.getValue(); }
    const PDFInteger* getColSpan() const {  return m_colSpan.getValue(); }
    const QString* getColumnWidths() const {  return m_columnWidths.getValue(); }
    const XFA_Measurement* getH() const {  return m_h.getValue(); }
    const HALIGN* getHAlign() const {  return m_hAlign.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const LAYOUT* getLayout() const {  return m_layout.getValue(); }
    const QString* getLocale() const {  return m_locale.getValue(); }
    const XFA_Measurement* getMaxH() const {  return m_maxH.getValue(); }
    const XFA_Measurement* getMaxW() const {  return m_maxW.getValue(); }
    const MERGEMODE* getMergeMode() const {  return m_mergeMode.getValue(); }
    const XFA_Measurement* getMinH() const {  return m_minH.getValue(); }
    const XFA_Measurement* getMinW() const {  return m_minW.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const PRESENCE* getPresence() const {  return m_presence.getValue(); }
    const QString* getRelevant() const {  return m_relevant.getValue(); }
    const RESTORESTATE* getRestoreState() const {  return m_restoreState.getValue(); }
    const SCOPE* getScope() const {  return m_scope.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }
    const XFA_Measurement* getW() const {  return m_w.getValue(); }
    const XFA_Measurement* getX() const {  return m_x.getValue(); }
    const XFA_Measurement* getY() const {  return m_y.getValue(); }

    const XFA_assist* getAssist() const {  return m_assist.getValue(); }
    const XFA_bind* getBind() const {  return m_bind.getValue(); }
    const XFA_bookend* getBookend() const {  return m_bookend.getValue(); }
    const XFA_border* getBorder() const {  return m_border.getValue(); }
    const XFA_break* getBreak() const {  return m_break.getValue(); }
    const XFA_calculate* getCalculate() const {  return m_calculate.getValue(); }
    const XFA_desc* getDesc() const {  return m_desc.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_keep* getKeep() const {  return m_keep.getValue(); }
    const XFA_margin* getMargin() const {  return m_margin.getValue(); }
    const XFA_occur* getOccur() const {  return m_occur.getValue(); }
    const XFA_overflow* getOverflow() const {  return m_overflow.getValue(); }
    const XFA_pageSet* getPageSet() const {  return m_pageSet.getValue(); }
    const XFA_para* getPara() const {  return m_para.getValue(); }
    const XFA_traversal* getTraversal() const {  return m_traversal.getValue(); }
    const XFA_validate* getValidate() const {  return m_validate.getValue(); }
    const XFA_variables* getVariables() const {  return m_variables.getValue(); }
    const std::vector<XFA_Node<XFA_area>>& getArea() const {  return m_area; }
    const std::vector<XFA_Node<XFA_breakAfter>>& getBreakAfter() const {  return m_breakAfter; }
    const std::vector<XFA_Node<XFA_breakBefore>>& getBreakBefore() const {  return m_breakBefore; }
    const std::vector<XFA_Node<XFA_connect>>& getConnect() const {  return m_connect; }
    const std::vector<XFA_Node<XFA_draw>>& getDraw() const {  return m_draw; }
    const std::vector<XFA_Node<XFA_event>>& getEvent() const {  return m_event; }
    const std::vector<XFA_Node<XFA_exObject>>& getExObject() const {  return m_exObject; }
    const std::vector<XFA_Node<XFA_exclGroup>>& getExclGroup() const {  return m_exclGroup; }
    const std::vector<XFA_Node<XFA_field>>& getField() const {  return m_field; }
    const std::vector<XFA_Node<XFA_proto>>& getProto() const {  return m_proto; }
    const std::vector<XFA_Node<XFA_setProperty>>& getSetProperty() const {  return m_setProperty; }
    const std::vector<XFA_Node<XFA_subform>>& getSubform() const {  return m_subform; }
    const std::vector<XFA_Node<XFA_subformSet>>& getSubformSet() const {  return m_subformSet; }

    static std::optional<XFA_subform> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<ACCESS> m_access;
    XFA_Attribute<bool> m_allowMacro;
    XFA_Attribute<ANCHORTYPE> m_anchorType;
    XFA_Attribute<PDFInteger> m_colSpan;
    XFA_Attribute<QString> m_columnWidths;
    XFA_Attribute<XFA_Measurement> m_h;
    XFA_Attribute<HALIGN> m_hAlign;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<LAYOUT> m_layout;
    XFA_Attribute<QString> m_locale;
    XFA_Attribute<XFA_Measurement> m_maxH;
    XFA_Attribute<XFA_Measurement> m_maxW;
    XFA_Attribute<MERGEMODE> m_mergeMode;
    XFA_Attribute<XFA_Measurement> m_minH;
    XFA_Attribute<XFA_Measurement> m_minW;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<PRESENCE> m_presence;
    XFA_Attribute<QString> m_relevant;
    XFA_Attribute<RESTORESTATE> m_restoreState;
    XFA_Attribute<SCOPE> m_scope;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;
    XFA_Attribute<XFA_Measurement> m_w;
    XFA_Attribute<XFA_Measurement> m_x;
    XFA_Attribute<XFA_Measurement> m_y;

    /* subnodes */
    XFA_Node<XFA_assist> m_assist;
    XFA_Node<XFA_bind> m_bind;
    XFA_Node<XFA_bookend> m_bookend;
    XFA_Node<XFA_border> m_border;
    XFA_Node<XFA_break> m_break;
    XFA_Node<XFA_calculate> m_calculate;
    XFA_Node<XFA_desc> m_desc;
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_keep> m_keep;
    XFA_Node<XFA_margin> m_margin;
    XFA_Node<XFA_occur> m_occur;
    XFA_Node<XFA_overflow> m_overflow;
    XFA_Node<XFA_pageSet> m_pageSet;
    XFA_Node<XFA_para> m_para;
    XFA_Node<XFA_traversal> m_traversal;
    XFA_Node<XFA_validate> m_validate;
    XFA_Node<XFA_variables> m_variables;
    std::vector<XFA_Node<XFA_area>> m_area;
    std::vector<XFA_Node<XFA_breakAfter>> m_breakAfter;
    std::vector<XFA_Node<XFA_breakBefore>> m_breakBefore;
    std::vector<XFA_Node<XFA_connect>> m_connect;
    std::vector<XFA_Node<XFA_draw>> m_draw;
    std::vector<XFA_Node<XFA_event>> m_event;
    std::vector<XFA_Node<XFA_exObject>> m_exObject;
    std::vector<XFA_Node<XFA_exclGroup>> m_exclGroup;
    std::vector<XFA_Node<XFA_field>> m_field;
    std::vector<XFA_Node<XFA_proto>> m_proto;
    std::vector<XFA_Node<XFA_setProperty>> m_setProperty;
    std::vector<XFA_Node<XFA_subform>> m_subform;
    std::vector<XFA_Node<XFA_subformSet>> m_subformSet;
};

std::optional<XFA_subform> XFA_subform::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_subform myClass;

    // load attributes
    parseAttribute(element, "access", myClass.m_access, "open");
    parseAttribute(element, "allowMacro", myClass.m_allowMacro, "0");
    parseAttribute(element, "anchorType", myClass.m_anchorType, "topLeft");
    parseAttribute(element, "colSpan", myClass.m_colSpan, "1");
    parseAttribute(element, "columnWidths", myClass.m_columnWidths, "");
    parseAttribute(element, "h", myClass.m_h, "0in");
    parseAttribute(element, "hAlign", myClass.m_hAlign, "left");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "layout", myClass.m_layout, "position");
    parseAttribute(element, "locale", myClass.m_locale, "");
    parseAttribute(element, "maxH", myClass.m_maxH, "0in");
    parseAttribute(element, "maxW", myClass.m_maxW, "0in");
    parseAttribute(element, "mergeMode", myClass.m_mergeMode, "consumeData");
    parseAttribute(element, "minH", myClass.m_minH, "0in");
    parseAttribute(element, "minW", myClass.m_minW, "0in");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "presence", myClass.m_presence, "visible");
    parseAttribute(element, "relevant", myClass.m_relevant, "");
    parseAttribute(element, "restoreState", myClass.m_restoreState, "manual");
    parseAttribute(element, "scope", myClass.m_scope, "name");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");
    parseAttribute(element, "w", myClass.m_w, "0in");
    parseAttribute(element, "x", myClass.m_x, "0in");
    parseAttribute(element, "y", myClass.m_y, "0in");

    // load items
    parseItem(element, "assist", myClass.m_assist);
    parseItem(element, "bind", myClass.m_bind);
    parseItem(element, "bookend", myClass.m_bookend);
    parseItem(element, "border", myClass.m_border);
    parseItem(element, "break", myClass.m_break);
    parseItem(element, "calculate", myClass.m_calculate);
    parseItem(element, "desc", myClass.m_desc);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "keep", myClass.m_keep);
    parseItem(element, "margin", myClass.m_margin);
    parseItem(element, "occur", myClass.m_occur);
    parseItem(element, "overflow", myClass.m_overflow);
    parseItem(element, "pageSet", myClass.m_pageSet);
    parseItem(element, "para", myClass.m_para);
    parseItem(element, "traversal", myClass.m_traversal);
    parseItem(element, "validate", myClass.m_validate);
    parseItem(element, "variables", myClass.m_variables);
    parseItem(element, "area", myClass.m_area);
    parseItem(element, "breakAfter", myClass.m_breakAfter);
    parseItem(element, "breakBefore", myClass.m_breakBefore);
    parseItem(element, "connect", myClass.m_connect);
    parseItem(element, "draw", myClass.m_draw);
    parseItem(element, "event", myClass.m_event);
    parseItem(element, "exObject", myClass.m_exObject);
    parseItem(element, "exclGroup", myClass.m_exclGroup);
    parseItem(element, "field", myClass.m_field);
    parseItem(element, "proto", myClass.m_proto);
    parseItem(element, "setProperty", myClass.m_setProperty);
    parseItem(element, "subform", myClass.m_subform);
    parseItem(element, "subformSet", myClass.m_subformSet);
    return myClass;
}


class XFA_subformSet : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const RELATION1* getRelation() const {  return m_relation.getValue(); }
    const QString* getRelevant() const {  return m_relevant.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_bookend* getBookend() const {  return m_bookend.getValue(); }
    const XFA_break* getBreak() const {  return m_break.getValue(); }
    const XFA_desc* getDesc() const {  return m_desc.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_occur* getOccur() const {  return m_occur.getValue(); }
    const XFA_overflow* getOverflow() const {  return m_overflow.getValue(); }
    const std::vector<XFA_Node<XFA_breakAfter>>& getBreakAfter() const {  return m_breakAfter; }
    const std::vector<XFA_Node<XFA_breakBefore>>& getBreakBefore() const {  return m_breakBefore; }
    const std::vector<XFA_Node<XFA_subform>>& getSubform() const {  return m_subform; }
    const std::vector<XFA_Node<XFA_subformSet>>& getSubformSet() const {  return m_subformSet; }

    static std::optional<XFA_subformSet> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<RELATION1> m_relation;
    XFA_Attribute<QString> m_relevant;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_bookend> m_bookend;
    XFA_Node<XFA_break> m_break;
    XFA_Node<XFA_desc> m_desc;
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_occur> m_occur;
    XFA_Node<XFA_overflow> m_overflow;
    std::vector<XFA_Node<XFA_breakAfter>> m_breakAfter;
    std::vector<XFA_Node<XFA_breakBefore>> m_breakBefore;
    std::vector<XFA_Node<XFA_subform>> m_subform;
    std::vector<XFA_Node<XFA_subformSet>> m_subformSet;
};

std::optional<XFA_subformSet> XFA_subformSet::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_subformSet myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "relation", myClass.m_relation, "ordered");
    parseAttribute(element, "relevant", myClass.m_relevant, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "bookend", myClass.m_bookend);
    parseItem(element, "break", myClass.m_break);
    parseItem(element, "desc", myClass.m_desc);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "occur", myClass.m_occur);
    parseItem(element, "overflow", myClass.m_overflow);
    parseItem(element, "breakAfter", myClass.m_breakAfter);
    parseItem(element, "breakBefore", myClass.m_breakBefore);
    parseItem(element, "subform", myClass.m_subform);
    parseItem(element, "subformSet", myClass.m_subformSet);
    return myClass;
}


class XFA_subjectDN : public XFA_BaseNode
{
public:

    const QString* getDelimiter() const {  return m_delimiter.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_subjectDN> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_delimiter;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_subjectDN> XFA_subjectDN::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_subjectDN myClass;

    // load attributes
    parseAttribute(element, "delimiter", myClass.m_delimiter, "");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_subjectDNs : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const TYPE* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const std::vector<XFA_Node<XFA_subjectDN>>& getSubjectDN() const {  return m_subjectDN; }

    static std::optional<XFA_subjectDNs> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<TYPE> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    std::vector<XFA_Node<XFA_subjectDN>> m_subjectDN;
};

std::optional<XFA_subjectDNs> XFA_subjectDNs::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_subjectDNs myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "type", myClass.m_type, "optional");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "subjectDN", myClass.m_subjectDN);
    return myClass;
}


class XFA_submit : public XFA_BaseNode
{
public:

    const bool* getEmbedPDF() const {  return m_embedPDF.getValue(); }
    const FORMAT* getFormat() const {  return m_format.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const QString* getTarget() const {  return m_target.getValue(); }
    const QString* getTextEncoding() const {  return m_textEncoding.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }
    const QString* getXdpContent() const {  return m_xdpContent.getValue(); }

    const XFA_encrypt* getEncrypt() const {  return m_encrypt.getValue(); }
    const std::vector<XFA_Node<XFA_encryptData>>& getEncryptData() const {  return m_encryptData; }
    const std::vector<XFA_Node<XFA_signData>>& getSignData() const {  return m_signData; }

    static std::optional<XFA_submit> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<bool> m_embedPDF;
    XFA_Attribute<FORMAT> m_format;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_target;
    XFA_Attribute<QString> m_textEncoding;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;
    XFA_Attribute<QString> m_xdpContent;

    /* subnodes */
    XFA_Node<XFA_encrypt> m_encrypt;
    std::vector<XFA_Node<XFA_encryptData>> m_encryptData;
    std::vector<XFA_Node<XFA_signData>> m_signData;
};

std::optional<XFA_submit> XFA_submit::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_submit myClass;

    // load attributes
    parseAttribute(element, "embedPDF", myClass.m_embedPDF, "0");
    parseAttribute(element, "format", myClass.m_format, "xdp");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "target", myClass.m_target, "");
    parseAttribute(element, "textEncoding", myClass.m_textEncoding, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");
    parseAttribute(element, "xdpContent", myClass.m_xdpContent, "");

    // load items
    parseItem(element, "encrypt", myClass.m_encrypt);
    parseItem(element, "encryptData", myClass.m_encryptData);
    parseItem(element, "signData", myClass.m_signData);
    return myClass;
}


class XFA_template : public XFA_BaseNode
{
public:

    const BASEPROFILE* getBaseProfile() const {  return m_baseProfile.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const std::vector<XFA_Node<XFA_subform>>& getSubform() const {  return m_subform; }

    static std::optional<XFA_template> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<BASEPROFILE> m_baseProfile;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
    std::vector<XFA_Node<XFA_subform>> m_subform;
};

std::optional<XFA_template> XFA_template::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_template myClass;

    // load attributes
    parseAttribute(element, "baseProfile", myClass.m_baseProfile, "full");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "subform", myClass.m_subform);
    return myClass;
}


class XFA_text : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const PDFInteger* getMaxChars() const {  return m_maxChars.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getRid() const {  return m_rid.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_text> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<PDFInteger> m_maxChars;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_rid;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_text> XFA_text::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_text myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "maxChars", myClass.m_maxChars, "0");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "rid", myClass.m_rid, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_textEdit : public XFA_BaseNode
{
public:

    const bool* getAllowRichText() const {  return m_allowRichText.getValue(); }
    const HSCROLLPOLICY* getHScrollPolicy() const {  return m_hScrollPolicy.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const MULTILINE* getMultiLine() const {  return m_multiLine.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }
    const VSCROLLPOLICY* getVScrollPolicy() const {  return m_vScrollPolicy.getValue(); }

    const XFA_border* getBorder() const {  return m_border.getValue(); }
    const XFA_comb* getComb() const {  return m_comb.getValue(); }
    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_margin* getMargin() const {  return m_margin.getValue(); }

    static std::optional<XFA_textEdit> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<bool> m_allowRichText;
    XFA_Attribute<HSCROLLPOLICY> m_hScrollPolicy;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<MULTILINE> m_multiLine;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;
    XFA_Attribute<VSCROLLPOLICY> m_vScrollPolicy;

    /* subnodes */
    XFA_Node<XFA_border> m_border;
    XFA_Node<XFA_comb> m_comb;
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_margin> m_margin;
};

std::optional<XFA_textEdit> XFA_textEdit::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_textEdit myClass;

    // load attributes
    parseAttribute(element, "allowRichText", myClass.m_allowRichText, "0");
    parseAttribute(element, "hScrollPolicy", myClass.m_hScrollPolicy, "auto");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "multiLine", myClass.m_multiLine, "1");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");
    parseAttribute(element, "vScrollPolicy", myClass.m_vScrollPolicy, "auto");

    // load items
    parseItem(element, "border", myClass.m_border);
    parseItem(element, "comb", myClass.m_comb);
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "margin", myClass.m_margin);
    return myClass;
}


class XFA_time : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getName() const {  return m_name.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_time> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_name;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_time> XFA_time::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_time myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "name", myClass.m_name, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_timeStamp : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getServer() const {  return m_server.getValue(); }
    const TYPE* getType() const {  return m_type.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    static std::optional<XFA_timeStamp> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_server;
    XFA_Attribute<TYPE> m_type;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
};

std::optional<XFA_timeStamp> XFA_timeStamp::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_timeStamp myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "server", myClass.m_server, "");
    parseAttribute(element, "type", myClass.m_type, "optional");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_toolTip : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getRid() const {  return m_rid.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }


    const QString* getNodeValue() const {  return m_nodeValue.getValue(); }

    static std::optional<XFA_toolTip> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_rid;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */

    XFA_Value<QString> m_nodeValue;
};

std::optional<XFA_toolTip> XFA_toolTip::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_toolTip myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "rid", myClass.m_rid, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    return myClass;
}


class XFA_traversal : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const std::vector<XFA_Node<XFA_traverse>>& getTraverse() const {  return m_traverse; }

    static std::optional<XFA_traversal> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
    std::vector<XFA_Node<XFA_traverse>> m_traverse;
};

std::optional<XFA_traversal> XFA_traversal::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_traversal myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "traverse", myClass.m_traverse);
    return myClass;
}


class XFA_traverse : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const OPERATION2* getOperation() const {  return m_operation.getValue(); }
    const QString* getRef() const {  return m_ref.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_script* getScript() const {  return m_script.getValue(); }

    static std::optional<XFA_traverse> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<OPERATION2> m_operation;
    XFA_Attribute<QString> m_ref;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_script> m_script;
};

std::optional<XFA_traverse> XFA_traverse::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_traverse myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "operation", myClass.m_operation, "next");
    parseAttribute(element, "ref", myClass.m_ref, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "script", myClass.m_script);
    return myClass;
}


class XFA_ui : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_picture* getPicture() const {  return m_picture.getValue(); }
    const XFA_barcode* getBarcode() const {  return m_barcode.getValue(); }
    const XFA_button* getButton() const {  return m_button.getValue(); }
    const XFA_checkButton* getCheckButton() const {  return m_checkButton.getValue(); }
    const XFA_choiceList* getChoiceList() const {  return m_choiceList.getValue(); }
    const XFA_dateTimeEdit* getDateTimeEdit() const {  return m_dateTimeEdit.getValue(); }
    const XFA_defaultUi* getDefaultUi() const {  return m_defaultUi.getValue(); }
    const XFA_imageEdit* getImageEdit() const {  return m_imageEdit.getValue(); }
    const XFA_numericEdit* getNumericEdit() const {  return m_numericEdit.getValue(); }
    const XFA_passwordEdit* getPasswordEdit() const {  return m_passwordEdit.getValue(); }
    const XFA_signature* getSignature() const {  return m_signature.getValue(); }
    const XFA_textEdit* getTextEdit() const {  return m_textEdit.getValue(); }

    static std::optional<XFA_ui> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_picture> m_picture;
    XFA_Node<XFA_barcode> m_barcode;
    XFA_Node<XFA_button> m_button;
    XFA_Node<XFA_checkButton> m_checkButton;
    XFA_Node<XFA_choiceList> m_choiceList;
    XFA_Node<XFA_dateTimeEdit> m_dateTimeEdit;
    XFA_Node<XFA_defaultUi> m_defaultUi;
    XFA_Node<XFA_imageEdit> m_imageEdit;
    XFA_Node<XFA_numericEdit> m_numericEdit;
    XFA_Node<XFA_passwordEdit> m_passwordEdit;
    XFA_Node<XFA_signature> m_signature;
    XFA_Node<XFA_textEdit> m_textEdit;
};

std::optional<XFA_ui> XFA_ui::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_ui myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "picture", myClass.m_picture);
    parseItem(element, "barcode", myClass.m_barcode);
    parseItem(element, "button", myClass.m_button);
    parseItem(element, "checkButton", myClass.m_checkButton);
    parseItem(element, "choiceList", myClass.m_choiceList);
    parseItem(element, "dateTimeEdit", myClass.m_dateTimeEdit);
    parseItem(element, "defaultUi", myClass.m_defaultUi);
    parseItem(element, "imageEdit", myClass.m_imageEdit);
    parseItem(element, "numericEdit", myClass.m_numericEdit);
    parseItem(element, "passwordEdit", myClass.m_passwordEdit);
    parseItem(element, "signature", myClass.m_signature);
    parseItem(element, "textEdit", myClass.m_textEdit);
    return myClass;
}


class XFA_validate : public XFA_BaseNode
{
public:

    const FORMATTEST* getFormatTest() const {  return m_formatTest.getValue(); }
    const QString* getId() const {  return m_id.getValue(); }
    const NULLTEST* getNullTest() const {  return m_nullTest.getValue(); }
    const SCRIPTTEST* getScriptTest() const {  return m_scriptTest.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_extras* getExtras() const {  return m_extras.getValue(); }
    const XFA_message* getMessage() const {  return m_message.getValue(); }
    const XFA_picture* getPicture() const {  return m_picture.getValue(); }
    const XFA_script* getScript() const {  return m_script.getValue(); }

    static std::optional<XFA_validate> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<FORMATTEST> m_formatTest;
    XFA_Attribute<QString> m_id;
    XFA_Attribute<NULLTEST> m_nullTest;
    XFA_Attribute<SCRIPTTEST> m_scriptTest;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_extras> m_extras;
    XFA_Node<XFA_message> m_message;
    XFA_Node<XFA_picture> m_picture;
    XFA_Node<XFA_script> m_script;
};

std::optional<XFA_validate> XFA_validate::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_validate myClass;

    // load attributes
    parseAttribute(element, "formatTest", myClass.m_formatTest, "warning");
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "nullTest", myClass.m_nullTest, "disabled");
    parseAttribute(element, "scriptTest", myClass.m_scriptTest, "error");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "extras", myClass.m_extras);
    parseItem(element, "message", myClass.m_message);
    parseItem(element, "picture", myClass.m_picture);
    parseItem(element, "script", myClass.m_script);
    return myClass;
}


class XFA_value : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const bool* getOverride() const {  return m_override.getValue(); }
    const QString* getRelevant() const {  return m_relevant.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const XFA_arc* getArc() const {  return m_arc.getValue(); }
    const XFA_boolean* getBoolean() const {  return m_boolean.getValue(); }
    const XFA_date* getDate() const {  return m_date.getValue(); }
    const XFA_dateTime* getDateTime() const {  return m_dateTime.getValue(); }
    const XFA_decimal* getDecimal() const {  return m_decimal.getValue(); }
    const XFA_exData* getExData() const {  return m_exData.getValue(); }
    const XFA_float* getFloat() const {  return m_float.getValue(); }
    const XFA_image* getImage() const {  return m_image.getValue(); }
    const XFA_integer* getInteger() const {  return m_integer.getValue(); }
    const XFA_line* getLine() const {  return m_line.getValue(); }
    const XFA_rectangle* getRectangle() const {  return m_rectangle.getValue(); }
    const XFA_text* getText() const {  return m_text.getValue(); }
    const XFA_time* getTime() const {  return m_time.getValue(); }

    static std::optional<XFA_value> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<bool> m_override;
    XFA_Attribute<QString> m_relevant;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    XFA_Node<XFA_arc> m_arc;
    XFA_Node<XFA_boolean> m_boolean;
    XFA_Node<XFA_date> m_date;
    XFA_Node<XFA_dateTime> m_dateTime;
    XFA_Node<XFA_decimal> m_decimal;
    XFA_Node<XFA_exData> m_exData;
    XFA_Node<XFA_float> m_float;
    XFA_Node<XFA_image> m_image;
    XFA_Node<XFA_integer> m_integer;
    XFA_Node<XFA_line> m_line;
    XFA_Node<XFA_rectangle> m_rectangle;
    XFA_Node<XFA_text> m_text;
    XFA_Node<XFA_time> m_time;
};

std::optional<XFA_value> XFA_value::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_value myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "override", myClass.m_override, "0");
    parseAttribute(element, "relevant", myClass.m_relevant, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "arc", myClass.m_arc);
    parseItem(element, "boolean", myClass.m_boolean);
    parseItem(element, "date", myClass.m_date);
    parseItem(element, "dateTime", myClass.m_dateTime);
    parseItem(element, "decimal", myClass.m_decimal);
    parseItem(element, "exData", myClass.m_exData);
    parseItem(element, "float", myClass.m_float);
    parseItem(element, "image", myClass.m_image);
    parseItem(element, "integer", myClass.m_integer);
    parseItem(element, "line", myClass.m_line);
    parseItem(element, "rectangle", myClass.m_rectangle);
    parseItem(element, "text", myClass.m_text);
    parseItem(element, "time", myClass.m_time);
    return myClass;
}


class XFA_variables : public XFA_BaseNode
{
public:

    const QString* getId() const {  return m_id.getValue(); }
    const QString* getUse() const {  return m_use.getValue(); }
    const QString* getUsehref() const {  return m_usehref.getValue(); }

    const std::vector<XFA_Node<XFA_boolean>>& getBoolean() const {  return m_boolean; }
    const std::vector<XFA_Node<XFA_date>>& getDate() const {  return m_date; }
    const std::vector<XFA_Node<XFA_dateTime>>& getDateTime() const {  return m_dateTime; }
    const std::vector<XFA_Node<XFA_decimal>>& getDecimal() const {  return m_decimal; }
    const std::vector<XFA_Node<XFA_exData>>& getExData() const {  return m_exData; }
    const std::vector<XFA_Node<XFA_float>>& getFloat() const {  return m_float; }
    const std::vector<XFA_Node<XFA_image>>& getImage() const {  return m_image; }
    const std::vector<XFA_Node<XFA_integer>>& getInteger() const {  return m_integer; }
    const std::vector<XFA_Node<XFA_manifest>>& getManifest() const {  return m_manifest; }
    const std::vector<XFA_Node<XFA_script>>& getScript() const {  return m_script; }
    const std::vector<XFA_Node<XFA_text>>& getText() const {  return m_text; }
    const std::vector<XFA_Node<XFA_time>>& getTime() const {  return m_time; }

    static std::optional<XFA_variables> parse(const QDomElement& element);

private:
    /* properties */
    XFA_Attribute<QString> m_id;
    XFA_Attribute<QString> m_use;
    XFA_Attribute<QString> m_usehref;

    /* subnodes */
    std::vector<XFA_Node<XFA_boolean>> m_boolean;
    std::vector<XFA_Node<XFA_date>> m_date;
    std::vector<XFA_Node<XFA_dateTime>> m_dateTime;
    std::vector<XFA_Node<XFA_decimal>> m_decimal;
    std::vector<XFA_Node<XFA_exData>> m_exData;
    std::vector<XFA_Node<XFA_float>> m_float;
    std::vector<XFA_Node<XFA_image>> m_image;
    std::vector<XFA_Node<XFA_integer>> m_integer;
    std::vector<XFA_Node<XFA_manifest>> m_manifest;
    std::vector<XFA_Node<XFA_script>> m_script;
    std::vector<XFA_Node<XFA_text>> m_text;
    std::vector<XFA_Node<XFA_time>> m_time;
};

std::optional<XFA_variables> XFA_variables::parse(const QDomElement& element)
{
    if (element.isNull())
    {
        return std::nullopt;
    }

    XFA_variables myClass;

    // load attributes
    parseAttribute(element, "id", myClass.m_id, "");
    parseAttribute(element, "use", myClass.m_use, "");
    parseAttribute(element, "usehref", myClass.m_usehref, "");

    // load items
    parseItem(element, "boolean", myClass.m_boolean);
    parseItem(element, "date", myClass.m_date);
    parseItem(element, "dateTime", myClass.m_dateTime);
    parseItem(element, "decimal", myClass.m_decimal);
    parseItem(element, "exData", myClass.m_exData);
    parseItem(element, "float", myClass.m_float);
    parseItem(element, "image", myClass.m_image);
    parseItem(element, "integer", myClass.m_integer);
    parseItem(element, "manifest", myClass.m_manifest);
    parseItem(element, "script", myClass.m_script);
    parseItem(element, "text", myClass.m_text);
    parseItem(element, "time", myClass.m_time);
    return myClass;
}


} // namespace xfa


/* END GENERATED CODE */

class PDFXFAEngineImpl
{
public:
    PDFXFAEngineImpl() = default;

private:
    xfa::XFA_Node<xfa::XFA_template> m_template;
};

PDFXFAEngine::PDFXFAEngine() :
    m_impl(std::make_unique<PDFXFAEngineImpl>())
{

}

PDFXFAEngine::~PDFXFAEngine()
{

}

}   // namespace pdf