@xpack/doxygen2docusaurus 1.0.2 → 2.0.0

package/dist/doxygen/data-model/compounds/descriptiontype-dm.js

@@ -18,11 +18,40 @@ import { DocBookOnlyDataModel, HtmlOnlyDataModel } from './compounddef-dm.js';
 import { TocListDataModel } from './tableofcontentstype-dm.js';
 import { isUrl } from '../../../docusaurus/utils.js';
 // ----------------------------------------------------------------------------
-// A bit unusual, since string values should be stored as object properties.
-// However, for consistency reasons, for objects like XXXonly perhaps it is
-// better to use objects,
+/**
+ * Abstract base class for XML elements that contain simple string content.
+ *
+ * @remarks
+ * Whilst it might appear unusual to encapsulate string values within object
+ * properties, this approach maintains consistency with format-specific
+ * elements (such as XXXonly types) and provides a unified interface for
+ * XML content processing throughout the Doxygen data model hierarchy.
+ *
+ * @public
+ */
 export class AbstractStringType extends AbstractDataModelBase {
+    /**
+     * The textual content extracted from the XML element.
+     *
+     * @remarks
+     * This property stores the inner text content of XML elements that follow
+     * the simple string pattern, providing a standardised mechanism for
+     * accessing textual data within the Doxygen XML structure.
+     */
     text = '';
+    /**
+     * Constructs an AbstractStringType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the string data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor validates that the provided element contains inner text
+     * content and extracts it into the text property. The implementation
+     * ensures that no attributes are present on simple string elements,
+     * maintaining the expected XML schema constraints.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -47,11 +76,46 @@ export class AbstractStringType extends AbstractDataModelBase {
 //   </xsd:sequence>
 // </xsd:complexType>
 /**
+ * Abstract base class for Doxygen description elements containing mixed
+ * content.
+ *
+ * @remarks
+ * Implements the XML Schema definition for descriptionType elements, which
+ * support mixed content (character data between child elements). This class
+ * handles the complex structure of documentation descriptions including
+ * titles, paragraphs, internal sections, and hierarchical section elements.
+ *
+ * The implementation processes the sequence of optional title elements
+ * followed by various documentation components such as paragraphs, internal
+ * documentation, and nested section structures up to level 1.
+ *
  * @public
  */
 export class AbstractDescriptionType extends AbstractDataModelBase {
-    // Optional elements.
+    /**
+     * Optional title element for the description.
+     *
+     * @remarks
+     * Contains the title text for the description section when present.
+     * According to the XML schema, only one title element is permitted
+     * per description, hence the assertion that ensures uniqueness during
+     * parsing.
+     */
     title; // Only one.
+    /**
+     * Constructs an AbstractDescriptionType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the description data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes mixed content descriptions by iterating through
+     * all inner elements and handling text nodes, title elements, paragraphs,
+     * internal sections, and level-1 sections. The parser maintains the
+     * original order of elements in the children array whilst extracting
+     * the title into a separate property for convenient access.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -97,18 +161,69 @@ export class AbstractDescriptionType extends AbstractDataModelBase {
 // <xsd:attribute name="filename" type="xsd:string" use="optional"/>
 // </xsd:complexType>
 /**
+ * Abstract base class providing properties for listing-type XML elements.
+ *
+ * @remarks
+ * Defines the common structure for elements that contain code listings
+ * with optional filename attributes. This base class establishes the
+ * foundation for both full listing implementations and filtered subsets
+ * of code lines.
+ *
  * @public
  */
 export class AbstractListingTypeBase extends AbstractDataModelBase {
-    // Optional elements.
+    /**
+     * Array of code line elements within the listing.
+     *
+     * @remarks
+     * Contains the individual code lines that comprise the listing content.
+     * Each code line may include syntax highlighting information, line
+     * numbers, and cross-reference data depending on the source
+     * documentation configuration.
+     */
     codelines;
-    // Optional attributes.
+    /**
+     * Optional filename attribute for the listing source.
+     *
+     * @remarks
+     * Specifies the original filename of the source code when the listing
+     * represents content from a specific file. This attribute assists in
+     * providing context and navigation capabilities within the generated
+     * documentation.
+     */
     filename;
 }
 /**
+ * Abstract base class for processing listing-type XML elements with parsing
+ * logic.
+ *
+ * @remarks
+ * Extends the base listing properties with comprehensive XML parsing
+ * capabilities. This class handles the extraction of code lines and
+ * filename attributes from Doxygen XML structures, providing the
+ * foundation for program listings and similar code-containing elements.
+ *
+ * The parser processes codeline elements whilst ignoring textual content
+ * that may appear between structured elements, maintaining compatibility
+ * with the mixed-content nature of XML listings.
+ *
  * @public
  */
 export class AbstractListingType extends AbstractListingTypeBase {
+    /**
+     * Constructs an AbstractListingType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the listing data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes listing elements by extracting codeline
+     * children and filename attributes. Text content between elements is
+     * deliberately ignored to accommodate the mixed-content model of XML
+     * listings, focusing on the structured code line elements that contain
+     * the meaningful programming content.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -149,14 +264,66 @@ export class AbstractListingType extends AbstractListingTypeBase {
 }
 //  <xsd:element name="programlisting" type="listingType" />
 /**
+ * Data model for programlisting XML elements containing source code.
+ *
+ * @remarks
+ * Represents program listings that contain source code with optional
+ * syntax highlighting and line numbering. This implementation processes
+ * Doxygen's programlisting elements, which are commonly used to display
+ * code examples, function implementations, and other programming content
+ * within documentation.
+ *
  * @public
  */
 export class ProgramListingDataModel extends AbstractListingType {
+    /**
+     * Constructs a ProgramListingDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the programlisting data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractListingType to handle
+     * the standard listing processing whilst specifically identifying the
+     * element as a 'programlisting' type for proper XML schema compliance.
+     */
     constructor(xml, element) {
         super(xml, element, 'programlisting');
     }
 }
+/**
+ * Filtered data model for member-specific program listing content.
+ *
+ * @remarks
+ * Creates a subset of a program listing containing only the code lines
+ * that fall within a specified line number range. This class is particularly
+ * useful for displaying member function implementations or specific code
+ * sections within larger source files, enabling focused documentation
+ * that highlights relevant portions of the codebase.
+ *
+ * The filtering process preserves all code line attributes including
+ * syntax highlighting, cross-references, and line numbering whilst
+ * restricting the content to the specified range.
+ *
+ * @public
+ */
 export class MemberProgramListingDataModel extends AbstractListingTypeBase {
+    /**
+     * Constructs a filtered program listing for member-specific content.
+     *
+     * @param programListing - The source program listing to filter
+     * @param startLine - The first line number to include (inclusive)
+     * @param endLine - The last line number to include (inclusive)
+     *
+     * @remarks
+     * This constructor creates a new listing containing only the code lines
+     * that fall within the specified line number range. The filtering process
+     * examines each code line's line number attribute and includes only those
+     * lines where the number falls between startLine and endLine (inclusive).
+     *
+     * If no lines fall within the specified range, the codelines property
+     * remains undefined, indicating an empty filtered result.
+     */
     constructor(programListing, startLine, endLine) {
         super(programListing.elementName);
         assert(startLine <= endLine);
@@ -187,16 +354,83 @@ export class MemberProgramListingDataModel extends AbstractListingTypeBase {
 // <xsd:attribute name="external" type="DoxBool" />
 // </xsd:complexType>
 /**
+ * Abstract base class for code line elements with syntax highlighting support.
+ *
+ * @remarks
+ * Implements the XML Schema definition for codelineType elements, which
+ * represent individual lines of source code within program listings. Each
+ * code line may contain syntax highlighting information, line numbers,
+ * cross-references to documentation elements, and external link indicators.
+ *
+ * All attributes are optional according to the schema, allowing for flexible
+ * representation of code content ranging from simple text lines to fully
+ * annotated source code with comprehensive metadata.
+ *
  * @public
  */
 export class AbstractCodeLineType extends AbstractDataModelBase {
-    // Optional elements.
+    /**
+     * Array of syntax highlighting elements within the code line.
+     *
+     * @remarks
+     * Contains highlight elements that provide syntax colouring information
+     * for different parts of the code line. Each highlight element specifies
+     * a highlight class (such as keyword, comment, or string literal) and
+     * the corresponding text content to be styled.
+     */
     highlights;
-    // Optional attributes.
+    /**
+     * Optional line number for the code line.
+     *
+     * @remarks
+     * Specifies the line number of this code line within the source file.
+     * This attribute enables line-based navigation and referencing within
+     * the documentation system.
+     */
     lineno;
+    /**
+     * Optional reference identifier for cross-linking.
+     *
+     * @remarks
+     * Contains a reference ID that can be used to create hyperlinks to
+     * related documentation elements such as function definitions, variable
+     * declarations, or other documented entities.
+     */
     refid;
+    /**
+     * Optional reference kind classification.
+     *
+     * @remarks
+     * Specifies the type of reference represented by the refid attribute,
+     * such as compound, member, or other Doxygen reference kinds. This
+     * classification assists in determining the appropriate link target
+     * and display behaviour.
+     */
     refkind;
+    /**
+     * Optional flag indicating external reference status.
+     *
+     * @remarks
+     * When true, indicates that the reference points to an external
+     * documentation source rather than an element within the current
+     * documentation set. This flag influences link generation and
+     * navigation behaviour.
+     */
     external;
+    /**
+     * Constructs an AbstractCodeLineType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the code line data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes code line elements by extracting highlight
+     * children and optional attributes including line numbers, reference IDs,
+     * reference kinds, and external flags. The parser handles empty code
+     * lines gracefully whilst ignoring textual content that may appear
+     * between structured highlight elements.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -246,21 +480,74 @@ export class AbstractCodeLineType extends AbstractDataModelBase {
 }
 // <xsd:element name="codeline" type="codelineType" minOccurs="0" maxOccurs="unbounded" />
 /**
+ * Data model for individual code line elements within program listings.
+ *
+ * @remarks
+ * Represents a single line of source code with optional syntax highlighting,
+ * line numbering, and cross-reference information. This implementation
+ * processes Doxygen's codeline elements, which form the fundamental
+ * building blocks of program listings and code examples within the
+ * documentation.
+ *
  * @public
  */
 export class CodeLineDataModel extends AbstractCodeLineType {
+    /**
+     * Constructs a CodeLineDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the codeline data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractCodeLineType to handle
+     * the standard code line processing whilst specifically identifying the
+     * element as a 'codeline' type for proper XML schema compliance.
+     */
     constructor(xml, element) {
         super(xml, element, 'codeline');
     }
 }
 /**
+ * Abstract base class for syntax highlighting elements within code listings.
+ *
+ * @remarks
+ * Implements the XML Schema definition for highlightType elements, which
+ * provide syntax highlighting information for portions of source code.
+ * Each highlight element contains a mandatory class attribute that specifies
+ * the type of syntax element (keyword, comment, etc.) and may contain
+ * mixed content including text, spacing elements, and cross-references.
+ *
+ * The implementation supports the full range of Doxygen highlight classes
+ * including standard programming language constructs and specialised
+ * VHDL categories for hardware description language documentation.
+ *
  * @public
  */
 export class AbstractHighlightType extends AbstractDataModelBase {
-    // Any sequence of them.
-    // children: Array<string | SpDataModel | RefTextDataModel> = []
-    // Mandatory attributes.
+    /**
+     * Mandatory highlight classification attribute.
+     *
+     * @remarks
+     * Specifies the syntax highlighting class for this element, determining
+     * how the contained text should be styled in the generated documentation.
+     * The value must be one of the predefined DoxHighlightClass enumeration
+     * values such as 'keyword', 'comment', or 'stringliteral'.
+     */
     classs = '';
+    /**
+     * Constructs an AbstractHighlightType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the highlight data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes highlight elements by extracting the mandatory
+     * class attribute and any mixed content including text nodes, spacing
+     * elements, and cross-reference elements. The parser maintains the original
+     * order of content elements in the children array to preserve the intended
+     * layout and formatting of the highlighted code segment.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -305,9 +592,29 @@ export class AbstractHighlightType extends AbstractDataModelBase {
 }
 // <xsd:element name="highlight" type="highlightType" minOccurs="0" maxOccurs="unbounded" />
 /**
+ * Data model for syntax highlight elements within code listings.
+ *
+ * @remarks
+ * Represents individual syntax highlighting segments that specify how
+ * portions of source code should be styled in the generated documentation.
+ * This implementation processes Doxygen's highlight elements, which contain
+ * the highlight class information and associated text content for proper
+ * syntax colouring.
+ *
  * @public
  */
 export class HighlightDataModel extends AbstractHighlightType {
+    /**
+     * Constructs a HighlightDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the highlight data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractHighlightType to handle
+     * the standard highlight processing whilst specifically identifying the
+     * element as a 'highlight' type for proper XML schema compliance.
+     */
     constructor(xml, element) {
         super(xml, element, 'highlight');
     }
@@ -315,10 +622,55 @@ export class HighlightDataModel extends AbstractHighlightType {
 // <xsd:complexType name="spType" mixed="true">   <-- Character data is allowed to appear between the child elements!
 // <xsd:attribute name="value" type="xsd:integer" use="optional"/>
 // </xsd:complexType>
+/**
+ * Abstract base class for spacing elements within highlighted code.
+ *
+ * @remarks
+ * Implements the XML Schema definition for spType elements, which represent
+ * spacing or whitespace within syntax-highlighted code listings. These
+ * elements support mixed content and may include an optional numeric value
+ * attribute to specify the amount or type of spacing.
+ *
+ * Spacing elements are commonly used within highlight elements to preserve
+ * proper formatting and indentation of source code whilst maintaining
+ * the structured nature of the XML representation.
+ *
+ * @public
+ */
 export class AbstractSpType extends AbstractDataModelBase {
+    /**
+     * The textual content of the spacing element.
+     *
+     * @remarks
+     * Contains any text content associated with the spacing element. For
+     * simple whitespace elements, this typically contains space characters,
+     * tabs, or other whitespace sequences that preserve the original
+     * formatting of the source code.
+     */
     text = '';
-    // Optional attributes.
+    /**
+     * Optional numeric value attribute for spacing specifications.
+     *
+     * @remarks
+     * Specifies a numeric value that may indicate the amount of spacing,
+     * tab stops, or other formatting-related measurements. The interpretation
+     * of this value depends on the context and the specific spacing
+     * requirements of the documentation generator.
+     */
     value;
+    /**
+     * Constructs an AbstractSpType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the spacing data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes spacing elements by validating that they
+     * contain no inner elements (only text content) and extracting any
+     * optional value attribute. The implementation ensures proper handling
+     * of whitespace preservation within syntax-highlighted code sections.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -345,7 +697,30 @@ export class AbstractSpType extends AbstractDataModelBase {
     }
 }
 // <xsd:element name="sp" type="spType" />
+/**
+ * Data model for spacing elements within syntax-highlighted code.
+ *
+ * @remarks
+ * Represents individual spacing elements that preserve whitespace and
+ * formatting within highlighted code segments. This implementation
+ * processes Doxygen's sp elements, which maintain proper indentation
+ * and spacing in source code listings whilst supporting the structured
+ * XML representation of the documentation.
+ *
+ * @public
+ */
 export class SpDataModel extends AbstractSpType {
+    /**
+     * Constructs a SpDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the spacing data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractSpType to handle
+     * the standard spacing processing whilst specifically identifying the
+     * element as an 'sp' type for proper XML schema compliance.
+     */
     constructor(xml, element) {
         super(xml, element, 'sp');
     }
@@ -362,12 +737,73 @@ export class SpDataModel extends AbstractSpType {
 //   </xsd:sequence>
 //   <xsd:attribute name="id" type="xsd:string" />
 // </xsd:complexType>
+/**
+ * Abstract base class for hierarchical documentation section elements.
+ *
+ * @remarks
+ * Provides the common structure for documentation sections at various
+ * levels of the hierarchy. All section types share the ability to have
+ * an optional title and an optional ID attribute for cross-referencing
+ * and navigation purposes.
+ *
+ * This base class establishes the foundation for the nested section
+ * structure that allows for well-organised documentation with proper
+ * hierarchical relationships between content elements.
+ *
+ * @public
+ */
 export class AbstractDocSectType extends AbstractDataModelBase {
+    /**
+     * Optional title element for the section.
+     *
+     * @remarks
+     * Contains the title data model for the section when present. Section
+     * titles provide descriptive headers that help organise and navigate
+     * the documentation content within the hierarchical structure.
+     */
     title;
-    // Optional attribute.
+    /**
+     * Optional identifier attribute for cross-referencing.
+     *
+     * @remarks
+     * Specifies a unique identifier for the section that can be used for
+     * cross-references, hyperlinks, and navigation within the documentation.
+     * This ID enables direct linking to specific sections from other parts
+     * of the documentation or external sources.
+     */
     id;
 }
+/**
+ * Abstract base class for first-level documentation section elements.
+ *
+ * @remarks
+ * Implements the XML Schema definition for docSect1Type elements, which
+ * represent the first level of hierarchical sections within documentation
+ * descriptions. These sections support mixed content and may contain
+ * titles, paragraphs, internal documentation sections, and nested
+ * second-level sections.
+ *
+ * First-level sections form the primary organisational structure for
+ * complex documentation content, enabling authors to create well-structured
+ * and navigable documentation with clear hierarchical relationships.
+ *
+ * @public
+ */
 export class AbstractDocSect1Type extends AbstractDocSectType {
+    /**
+     * Constructs an AbstractDocSect1Type instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the section data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes first-level section elements by extracting
+     * title elements, paragraphs, internal sections, and nested second-level
+     * sections. The parser maintains the original order of content elements
+     * whilst extracting titles and ID attributes for convenient access and
+     * cross-referencing capabilities.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -428,7 +864,38 @@ export class AbstractDocSect1Type extends AbstractDocSectType {
 //   </xsd:sequence>
 //   <xsd:attribute name="id" type="xsd:string" />
 // </xsd:complexType>
+/**
+ * Abstract base class for second-level documentation section elements.
+ *
+ * @remarks
+ * Implements the XML Schema definition for docSect2Type elements, which
+ * represent the second level of hierarchical sections within documentation
+ * descriptions. These sections support mixed content and may contain
+ * titles, paragraphs, internal documentation sections, and nested
+ * third-level sections.
+ *
+ * Second-level sections provide additional organisational depth for
+ * complex documentation structures, enabling detailed content organisation
+ * within first-level sections whilst maintaining clear hierarchical
+ * relationships.
+ *
+ * @public
+ */
 export class AbstractDocSect2Type extends AbstractDocSectType {
+    /**
+     * Constructs an AbstractDocSect2Type instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the section data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes second-level section elements by extracting
+     * title elements, paragraphs, internal sections, and nested third-level
+     * sections. The implementation maintains content ordering whilst providing
+     * structured access to section metadata and hierarchical content
+     * organisation.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -724,9 +1191,38 @@ export class AbstractDocSect6Type extends AbstractDocSectType {
 //     <xsd:element name="sect1" type="docSect1Type" minOccurs="0" maxOccurs="unbounded" />
 //   </xsd:sequence>
 // </xsd:complexType>
+/**
+ * Abstract base class for internal documentation section elements.
+ *
+ * @remarks
+ * Implements the XML Schema definition for docInternalType elements, which
+ * represent internal documentation sections containing mixed content. These
+ * sections typically contain implementation details, internal notes, or
+ * other content that may be conditionally included in the documentation
+ * output based on configuration settings.
+ *
+ * Internal sections support paragraphs and first-level sections, providing
+ * flexible content organisation for detailed technical information that
+ * may be intended for specific audiences or documentation contexts.
+ *
+ * @public
+ */
 export class AbstractDocInternalType extends AbstractDataModelBase {
-    // Any sequence of them.
-    // children: Array<string | ParaDataModel | Sect1DataModel> = []
+    /**
+     * Constructs an AbstractDocInternalType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the internal section
+     *   data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes internal documentation sections by extracting
+     * paragraphs and first-level sections whilst maintaining the mixed content
+     * structure. The implementation handles text nodes and structured elements
+     * in their original order to preserve the intended layout and flow of
+     * internal documentation content.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -994,6 +1490,27 @@ export class AbstractDocInternalS6Type extends AbstractDataModelBase {
         // console.log(util.inspect(this, { compact: false, depth: 999 }))
     }
 }
+/**
+ * Parser function for processing document title command group elements.
+ *
+ * @param xml - The Doxygen XML parser instance for processing XML content
+ * @param element - The XML element object containing the title command data
+ * @param elementName - The name of the XML element being processed
+ * @returns Array of parsed DocTitleCmdGroup elements
+ *
+ * @remarks
+ * This function processes XML elements that contain title command groups,
+ * parsing various markup elements such as bold text, emphasis, links,
+ * anchors, and special character entities. The parser recognises the
+ * different element types and creates appropriate data model instances
+ * for each command group element.
+ *
+ * The function handles the complex variety of inline markup elements
+ * that can appear within documentation titles, ensuring proper
+ * representation of formatting and cross-reference information.
+ *
+ * @public
+ */
 export function parseDocTitleCmdGroup(xml, element, elementName) {
     const children = [];
     // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -1837,9 +2354,38 @@ export function parseDocTitleCmdGroup(xml, element, elementName) {
 // <xsd:complexType name="docTitleType" mixed="true">   <-- Character data is allowed to appear between the child elements!
 //   <xsd:group ref="docTitleCmdGroup" minOccurs="0" maxOccurs="unbounded" />
 // </xsd:complexType>
+/**
+ * Base class for document title elements containing mixed content.
+ *
+ * @remarks
+ * Implements the XML Schema definition for docTitleType elements, which
+ * represent document titles containing mixed content including text and
+ * various title command group elements. These titles support rich formatting
+ * and interactive elements whilst maintaining proper structure for
+ * documentation headings and section titles.
+ *
+ * The implementation processes both textual content and structured markup
+ * elements, preserving their original order to maintain the intended
+ * formatting and presentation of title content within the documentation
+ * hierarchy.
+ *
+ * @public
+ */
 export class AbstractDocTitleType extends AbstractDataModelBase {
-    // Any sequence of them.
-    // children: Array<string | DocTitleCmdGroup> = []
+    /**
+     * Constructs an AbstractDocTitleType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the title data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes title elements by extracting both textual
+     * content and title command group elements. The parser maintains the
+     * original order of content elements whilst delegating structured element
+     * processing to the parseDocTitleCmdGroup function for comprehensive
+     * title markup support.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -1864,6 +2410,27 @@ export class AbstractDocTitleType extends AbstractDataModelBase {
         // console.log(util.inspect(this, { compact: false, depth: 999 }))
     }
 }
+/**
+ * Parser function for processing document command group elements.
+ *
+ * @param xml - The Doxygen XML parser instance for processing XML content
+ * @param element - The XML element object containing the command data
+ * @param elementName - The name of the XML element being processed
+ * @returns Array of parsed DocCmdGroup elements
+ *
+ * @remarks
+ * This function processes XML elements that contain document command groups,
+ * parsing various markup and structural elements such as formatting (bold,
+ * emphasis), interactive elements (links, references), lists, tables,
+ * sections, and special character entities. The parser recognises the
+ * different element types and creates appropriate data model instances.
+ *
+ * The function handles the comprehensive variety of documentation elements
+ * supported by Doxygen, ensuring proper representation of complex document
+ * structures and rich content formatting throughout the documentation system.
+ *
+ * @public
+ */
 function parseDocCmdGroup(xml, element, elementName) {
     const children = [];
     // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -2768,8 +3335,38 @@ function parseDocCmdGroup(xml, element, elementName) {
 // <xsd:complexType name="docParaType" mixed="true">   <-- Character data is allowed to appear between the child elements!
 //   <xsd:group ref="docCmdGroup" minOccurs="0" maxOccurs="unbounded" />
 // </xsd:complexType>
+/**
+ * Abstract base class for document paragraph elements containing mixed content.
+ *
+ * @remarks
+ * Implements the XML Schema definition for docParaType elements, which
+ * represent paragraphs within documentation containing mixed content including
+ * text and various document command group elements. These paragraphs form
+ * the fundamental content blocks within documentation structures, supporting
+ * rich formatting, cross-references, and embedded elements.
+ *
+ * The implementation processes both textual content and structured markup
+ * elements using the document command group parser, maintaining the original
+ * order of content elements to preserve the intended layout and presentation
+ * of paragraph content.
+ *
+ * @public
+ */
 export class AbstractDocParaType extends AbstractDataModelBase {
-    // children: Array<string | DocCmdGroup> = []
+    /**
+     * Constructs an AbstractDocParaType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the paragraph data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes paragraph elements by extracting both textual
+     * content and structured command group elements. The parser delegates
+     * structured element processing to the parseDocCmdGroup function to handle
+     * the full range of document markup elements whilst maintaining the
+     * original content order for proper paragraph presentation.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -2797,9 +3394,37 @@ export class AbstractDocParaType extends AbstractDataModelBase {
 // <xsd:complexType name="docMarkupType" mixed="true">   <-- Character data is allowed to appear between the child elements!
 //   <xsd:group ref="docCmdGroup" minOccurs="0" maxOccurs="unbounded" />
 // </xsd:complexType>
+/**
+ * Base class for document markup elements containing mixed content.
+ *
+ * @remarks
+ * Implements the XML Schema definition for docMarkupType elements, which
+ * represent markup containers that support mixed content including text
+ * and various document command group elements. These markup elements form
+ * the foundation for formatted content within documentation such as bold
+ * text, emphasis, and other inline formatting constructs.
+ *
+ * The implementation processes both textual content and structured markup
+ * elements, maintaining their original order to preserve the intended
+ * formatting and presentation of the documentation content.
+ *
+ * @public
+ */
 export class AbstractDocMarkupType extends AbstractDataModelBase {
-    // Any sequence of them.
-    // children: Array<string | DocCmdGroup> = []
+    /**
+     * Constructs an AbstractDocMarkupType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the markup data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes markup elements by extracting both textual
+     * content and structured command group elements. The parser maintains
+     * the original order of content elements whilst delegating structured
+     * element processing to the parseDocCmdGroup function for comprehensive
+     * markup support.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -2824,8 +3449,47 @@ export class AbstractDocMarkupType extends AbstractDataModelBase {
         // console.log(util.inspect(this, { compact: false, depth: 999 }))
     }
 }
+/**
+ * Specialised markup type for substring-based special character elements.
+ *
+ * @remarks
+ * Extends the base markup functionality to include a substring property
+ * that stores the actual character or character sequence represented by
+ * the markup element. This class is particularly useful for handling
+ * special character entities and symbols that need both structural
+ * representation and their corresponding textual output.
+ *
+ * The substring property enables proper rendering of special characters
+ * whilst maintaining the XML structure and metadata associated with
+ * the markup element.
+ *
+ * @public
+ */
 export class SubstringDocMarkupType extends AbstractDocMarkupType {
+    /**
+     * The character or character sequence represented by this markup element.
+     *
+     * @remarks
+     * Contains the actual textual representation of the special character
+     * or symbol that this markup element represents. This property enables
+     * proper text generation whilst preserving the structured markup
+     * information for documentation processing.
+     */
     substring;
+    /**
+     * Constructs a SubstringDocMarkupType with associated character data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the markup data
+     * @param elementName - The name of the XML element being processed
+     * @param substring - The character sequence this markup represents
+     *
+     * @remarks
+     * This constructor extends the base markup processing to associate
+     * specific character data with the markup element. This enables
+     * special character entities to maintain both their XML structure
+     * and their intended textual output for proper document generation.
+     */
     constructor(xml, element, elementName, substring) {
         super(xml, element, elementName);
         this.substring = substring;
@@ -4333,10 +4997,50 @@ export class RsquoDocMarkupDataModel extends SubstringDocMarkupType {
 //   <xsd:group ref="docTitleCmdGroup" minOccurs="0" maxOccurs="unbounded" />
 //   <xsd:attribute name="url" type="xsd:string" />
 // </xsd:complexType>
+/**
+ * Abstract base class for URL link elements within documentation content.
+ *
+ * @remarks
+ * Represents hyperlink elements that reference external URLs or web resources
+ * within documentation descriptions. This implementation processes Doxygen's
+ * URL link elements, which support mixed content including text and formatting
+ * commands within the link text, providing comprehensive support for rich
+ * hyperlink content.
+ *
+ * URL links contain a mandatory URL attribute and support child elements
+ * for formatted link text, enabling complex link presentations with styling
+ * and embedded markup whilst maintaining proper link functionality.
+ *
+ * @public
+ */
 export class AbstractDocURLLink extends AbstractDataModelBase {
     // children: Array<string | DocTitleCmdGroup> = []
-    // Mandatory attributes.
+    /**
+     * Target URL for the hyperlink.
+     *
+     * @remarks
+     * Contains the destination URL that the hyperlink should navigate to.
+     * This can be an absolute URL to external resources or a relative URL
+     * for internal navigation within the documentation structure.
+     */
     url = '';
+    /**
+     * Constructs an AbstractDocURLLink instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the URL link data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes URL link elements by extracting the mandatory
+     * URL attribute and processing any mixed content including text and
+     * formatting commands within the link. The implementation ensures that
+     * a valid URL is present and organises child elements for proper link
+     * text rendering.
+     *
+     * The URL attribute is validated to ensure proper link functionality
+     * within the generated documentation output.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -4372,7 +5076,33 @@ export class AbstractDocURLLink extends AbstractDataModelBase {
     }
 }
 // <xsd:element name="ulink" type="docURLLink" />
+/**
+ * Data model for URL link elements within documentation content.
+ *
+ * @remarks
+ * Represents hyperlink elements that reference external URLs or web resources
+ * within documentation descriptions. This implementation processes Doxygen's
+ * ulink elements, providing support for external linking with formatted
+ * link text and proper URL handling.
+ *
+ * URL links enable documentation to reference external resources, websites,
+ * specifications, and related materials whilst maintaining proper hyperlink
+ * functionality within the generated documentation output.
+ *
+ * @public
+ */
 export class UlinkDataModel extends AbstractDocURLLink {
+    /**
+     * Constructs a UlinkDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the URL link data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocURLLink whilst
+     * identifying the element as 'ulink' for proper URL link processing
+     * and hyperlink functionality within documentation generation workflows.
+     */
     constructor(xml, element) {
         super(xml, element, 'ulink');
     }
@@ -4381,10 +5111,49 @@ export class UlinkDataModel extends AbstractDocURLLink {
 // <xsd:complexType name="docAnchorType" mixed="true">   <-- Character data is allowed to appear between the child elements!
 //   <xsd:attribute name="id" type="xsd:string" />
 // </xsd:complexType>
+/**
+ * Abstract base class for anchor elements within documentation content.
+ *
+ * @remarks
+ * Represents anchor elements that provide navigation targets within
+ * documentation descriptions. This implementation processes Doxygen's
+ * anchor elements, which create bookmarks or jump targets that can be
+ * referenced by cross-references and hyperlinks within the documentation.
+ *
+ * Anchor elements contain a mandatory ID attribute that serves as the
+ * target identifier for navigation purposes. Whilst the schema allows
+ * mixed content, anchor elements are typically empty in practice and
+ * serve purely as navigation markers.
+ *
+ * @public
+ */
 export class AbstractDocAnchorType extends AbstractDataModelBase {
     // children: string[] = []
-    // Mandatory attributes.
+    /**
+     * Unique identifier for the anchor target.
+     *
+     * @remarks
+     * Contains the unique identifier that serves as the navigation target
+     * for cross-references and hyperlinks. This ID is used to generate
+     * HTML anchor elements and enable deep linking within documentation.
+     */
     id = '';
+    /**
+     * Constructs an AbstractDocAnchorType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the anchor data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes anchor elements by extracting the mandatory
+     * ID attribute whilst handling any unexpected content. Anchor elements
+     * are typically empty but the implementation provides error reporting
+     * for unexpected text content to ensure proper anchor functionality.
+     *
+     * The ID attribute is validated to ensure proper anchor target creation
+     * within the generated documentation output.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -4424,7 +5193,34 @@ export class AbstractDocAnchorType extends AbstractDataModelBase {
     }
 }
 // <xsd:element name="anchor" type="docAnchorType" />
+/**
+ * Data model for anchor elements within documentation content.
+ *
+ * @remarks
+ * Represents anchor elements that provide navigation targets within
+ * documentation descriptions. This implementation processes Doxygen's
+ * anchor elements, creating bookmarks or jump targets for cross-references
+ * and deep linking functionality within the documentation structure.
+ *
+ * Anchor elements enable precise navigation within documentation pages,
+ * allowing users to link directly to specific content sections and
+ * providing enhanced usability for complex documentation structures.
+ *
+ * @public
+ */
 export class AnchorDataModel extends AbstractDocAnchorType {
+    /**
+     * Constructs an AnchorDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the anchor data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocAnchorType whilst
+     * identifying the element as 'anchor' for proper navigation target
+     * creation and cross-reference functionality within documentation
+     * generation workflows.
+     */
     constructor(xml, element) {
         super(xml, element, 'anchor');
     }
@@ -4433,11 +5229,60 @@ export class AnchorDataModel extends AbstractDocAnchorType {
 // <xsd:complexType name="docFormulaType" mixed="true">   <-- Character data is allowed to appear between the child elements!
 //   <xsd:attribute name="id" type="xsd:string" />
 // </xsd:complexType>
+/**
+ * Abstract base class for mathematical formula elements within documentation.
+ *
+ * @remarks
+ * Represents mathematical formula elements that contain LaTeX expressions
+ * or mathematical notation within documentation descriptions. This
+ * implementation processes Doxygen's formula elements, which typically
+ * contain LaTeX code for mathematical expressions and equations.
+ *
+ * Formula elements include both an ID attribute for cross-referencing
+ * and text content containing the mathematical expression. The text
+ * content is usually LaTeX code that can be processed by mathematical
+ * rendering systems in the documentation output.
+ *
+ * @public
+ */
 export class AbstractDocFormulaType extends AbstractDataModelBase {
-    // Mandatory elements.
+    /**
+     * Mathematical expression or formula content.
+     *
+     * @remarks
+     * Contains the mathematical expression, typically in LaTeX format,
+     * that represents the formula. This text is processed by mathematical
+     * rendering systems to display properly formatted equations and
+     * expressions within the documentation output.
+     */
     text = ''; // The name of the reference, passed as element text.
-    // Mandatory attributes.
+    /**
+     * Unique identifier for the formula element.
+     *
+     * @remarks
+     * Contains the unique identifier for the formula that can be used for
+     * cross-referencing and linking within the documentation. This enables
+     * references to specific mathematical expressions from other parts of
+     * the documentation.
+     */
     id = '';
+    /**
+     * Constructs an AbstractDocFormulaType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the formula data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes formula elements by extracting the text
+     * content containing the mathematical expression and the mandatory ID
+     * attribute for cross-referencing. The implementation validates that
+     * both the formula text and ID are present to ensure proper mathematical
+     * content representation.
+     *
+     * The formula text is typically LaTeX code that requires appropriate
+     * rendering support in the documentation output system.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -4465,7 +5310,34 @@ export class AbstractDocFormulaType extends AbstractDataModelBase {
     }
 }
 // <xsd:element name="formula" type="docFormulaType" />
+/**
+ * Data model for mathematical formula elements within documentation content.
+ *
+ * @remarks
+ * Represents mathematical formula elements that contain LaTeX expressions
+ * or mathematical notation within documentation descriptions. This
+ * implementation processes Doxygen's formula elements, providing support
+ * for mathematical content including equations, expressions, and notation
+ * that enhance technical documentation.
+ *
+ * Formula elements enable the inclusion of properly formatted mathematical
+ * content within documentation, supporting complex technical documentation
+ * requirements for mathematical and scientific applications.
+ *
+ * @public
+ */
 export class FormulaDataModel extends AbstractDocFormulaType {
+    /**
+     * Constructs a FormulaDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the formula data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocFormulaType whilst
+     * identifying the element as 'formula' for proper mathematical content
+     * processing and rendering within documentation generation workflows.
+     */
     constructor(xml, element) {
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
         super(xml, element, 'formula');
@@ -4478,10 +5350,59 @@ export class FormulaDataModel extends AbstractDocFormulaType {
 //     <xsd:element name="secondaryie" type="xsd:string" />
 //   </xsd:sequence>
 // </xsd:complexType>
+/**
+ * Abstract base class for index entry elements within documentation.
+ *
+ * @remarks
+ * Represents index entry elements that define entries for documentation
+ * indices and keyword lists. This implementation processes Doxygen's
+ * index entry elements, which consist of primary and secondary index
+ * terms that enable comprehensive documentation indexing and search
+ * functionality.
+ *
+ * Index entries support hierarchical indexing with primary and secondary
+ * terms, allowing for detailed organisation of documentation content
+ * according to topics, concepts, and keywords for enhanced discoverability.
+ *
+ * @public
+ */
 export class AbstractDocIndexEntryType extends AbstractDataModelBase {
-    // Mandatory elements.
+    /**
+     * Primary index term or keyword.
+     *
+     * @remarks
+     * Contains the main index term that serves as the primary classification
+     * for the index entry. This term appears as the top-level entry in
+     * generated indices and search systems, providing the primary access
+     * point for content discovery.
+     */
     primaryie = '';
+    /**
+     * Secondary index term or sub-keyword.
+     *
+     * @remarks
+     * Contains the secondary index term that provides additional classification
+     * beneath the primary term. This enables hierarchical index organisation
+     * where related concepts can be grouped under broader categories for
+     * more precise content classification.
+     */
     secondaryie = '';
+    /**
+     * Constructs an AbstractDocIndexEntryType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the index entry data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes index entry elements by extracting the
+     * primary and secondary index terms from the XML content. The
+     * implementation handles both terms as optional to accommodate various
+     * indexing scenarios whilst providing comprehensive index functionality.
+     *
+     * The index terms are used to generate searchable indices and keyword
+     * lists that enhance documentation navigation and content discovery.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -4515,7 +5436,34 @@ export class AbstractDocIndexEntryType extends AbstractDataModelBase {
     }
 }
 // <xsd:element name="indexentry" type="docIndexEntryType" />
+/**
+ * Data model for index entry elements within documentation content.
+ *
+ * @remarks
+ * Represents index entry elements that define entries for documentation
+ * indices and keyword lists. This implementation processes Doxygen's
+ * indexentry elements, providing support for hierarchical indexing with
+ * primary and secondary terms that enhance content organisation and
+ * discoverability.
+ *
+ * Index entries enable comprehensive documentation indexing that supports
+ * search functionality and content navigation, helping users locate
+ * specific topics and concepts within large documentation sets.
+ *
+ * @public
+ */
 export class IndexEntryDataModel extends AbstractDocIndexEntryType {
+    /**
+     * Constructs an IndexEntryDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the index entry data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocIndexEntryType whilst
+     * identifying the element as 'indexentry' for proper index term processing
+     * and search functionality within documentation generation workflows.
+     */
     constructor(xml, element) {
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
         super(xml, element, 'indexentry');
@@ -4539,12 +5487,62 @@ export class IndexEntryDataModel extends AbstractDocIndexEntryType {
 //     <xsd:enumeration value="I" />
 //   </xsd:restriction>
 // </xsd:simpleType>
+/**
+ * Abstract base class for documentation list elements within content.
+ *
+ * @remarks
+ * Provides foundational structure for ordered and unordered list elements
+ * that organise content hierarchically within documentation. This abstract
+ * class manages list items and common attributes such as type and starting
+ * values, enabling consistent processing of various list formats including
+ * bullet points, numbered lists, and custom enumeration styles.
+ *
+ * Lists enhance content organisation by enabling clear presentation of
+ * structured information, supporting both simple and complex hierarchical
+ * arrangements that improve documentation readability and user comprehension.
+ *
+ * @public
+ */
 export class AbstractDocListType extends AbstractDataModelBase {
-    // Mandatory elements.
+    /**
+     * Array of list items contained within this list element.
+     *
+     * @remarks
+     * Contains all individual list items that constitute the list content,
+     * maintaining order and hierarchy for proper list rendering within
+     * documentation output.
+     */
     listItems = [];
-    // Optional attributes.
+    /**
+     * The list type identifier for formatting purposes.
+     *
+     * @remarks
+     * Specifies the list type such as 'bullet', 'number', or custom
+     * enumeration styles that determine the visual presentation of list items
+     * within the rendered documentation.
+     */
     type = '';
+    /**
+     * Optional starting value for ordered lists.
+     *
+     * @remarks
+     * Defines the initial value for numbered lists when custom starting
+     * points are required, allowing documentation to continue numbering from
+     * specific values or restart sequences as needed.
+     */
     start;
+    /**
+     * Constructs an AbstractDocListType from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the list data
+     * @param elementName - The XML element name for identification purposes
+     *
+     * @remarks
+     * This constructor processes XML list elements by extracting list items
+     * and attributes that define list behaviour and appearance, enabling
+     * proper list structure within documentation generation workflows.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -4595,12 +5593,62 @@ export class AbstractDocListType extends AbstractDataModelBase {
 //   <xsd:attribute name="override" type="DoxCheck" />
 //   <xsd:attribute name="value" type="xsd:integer" use="optional"/>
 // </xsd:complexType>
+/**
+ * Abstract base class for individual list item elements.
+ *
+ * @remarks
+ * Represents individual items within ordered and unordered lists, providing
+ * structure for list content including paragraphs and optional attributes
+ * that control list item presentation. This abstract class enables flexible
+ * list item processing whilst maintaining consistency across different list
+ * types and documentation contexts.
+ *
+ * List items support complex content including multiple paragraphs and
+ * custom numbering, allowing for rich documentation structures that enhance
+ * content organisation and readability within generated documentation.
+ *
+ * @public
+ */
 export class AbstractDocListItemType extends AbstractDataModelBase {
-    // Optional elements.
+    /**
+     * Optional array of paragraph elements within this list item.
+     *
+     * @remarks
+     * Contains paragraph content that constitutes the list item body,
+     * supporting rich content including text, formatting, and nested
+     * elements that enhance list item presentation.
+     */
     paras;
-    // Optional attributes.
+    /**
+     * Optional override attribute for list item customisation.
+     *
+     * @remarks
+     * Provides mechanism for overriding default list item presentation or
+     * behaviour, enabling custom formatting or special handling of specific
+     * list items within documentation generation.
+     */
     override;
+    /**
+     * Optional numeric value for ordered list items.
+     *
+     * @remarks
+     * Specifies custom numbering for ordered list items when default
+     * sequential numbering is insufficient, allowing for custom values and
+     * non-sequential list numbering in documentation output.
+     */
     value;
+    /**
+     * Constructs an AbstractDocListItemType from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the list item data
+     * @param elementName - The XML element name for identification purposes
+     *
+     * @remarks
+     * This constructor processes XML list item elements by extracting paragraph
+     * content and optional attributes that define list item behaviour and
+     * presentation within documentation generation workflows.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -4660,13 +5708,55 @@ export class ListItemDataModel extends AbstractDocListItemType {
 //   </xsd:sequence>
 //   <xsd:attribute name="kind" type="DoxSimpleSectKind" />
 // </xsd:complexType>
+/**
+ * Abstract base class for simple section elements with typed content.
+ *
+ * @remarks
+ * Implements the XML Schema definition for docSimpleSectType elements, which
+ * represent structured sections with specific semantic types such as 'note',
+ * 'warning', 'see', 'return', 'since', and others. These sections provide
+ * standardised content blocks for common documentation patterns and help
+ * organise information according to its purpose and meaning.
+ *
+ * Simple sections contain an optional title and a sequence of paragraphs,
+ * along with a mandatory kind attribute that specifies the semantic type
+ * of the section content.
+ *
+ * @public
+ */
 export class AbstractDocSimpleSectType extends AbstractDataModelBase {
-    // Optional elements.
-    title; // Only one.
-    // Any sequence of them.
-    // children: Array<string | ParaDataModel> = []
-    // Mandatory attributes.
+    /**
+     * Optional title for the simple section.
+     *
+     * @remarks
+     * Contains the title text for the simple section when present. Simple
+     * sections may have descriptive titles that provide additional context
+     * beyond the semantic type indicated by the kind attribute.
+     */
+    title;
+    /**
+     * Mandatory kind attribute specifying the section type.
+     *
+     * @remarks
+     * Specifies the semantic type of the simple section such as 'note',
+     * 'warning', 'see', 'return', 'since', 'version', 'author', or other
+     * predefined section types. This attribute determines how the section
+     * content should be interpreted and potentially styled in the output.
+     */
     kind = '';
+    /**
+     * Constructs an AbstractDocSimpleSectType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the simple section data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes simple section elements by extracting the
+     * title, paragraph content, and mandatory kind attribute. The implementation
+     * validates the presence of the kind attribute and organises content
+     * elements whilst maintaining their original order for proper presentation.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -4731,14 +5821,64 @@ export class AbstractDocSimpleSectType extends AbstractDataModelBase {
 //   <xsd:attribute name="kindref" type="DoxRefKind" />
 //   <xsd:attribute name="external" type="xsd:string" />
 // </xsd:complexType>
+/**
+ * Abstract base class for reference text elements with links.
+ *
+ * @remarks
+ * Represents textual references that link to other documentation elements,
+ * providing cross-reference functionality within documentation content.
+ * This abstract class handles mixed content including text and formatting
+ * elements alongside reference attributes that specify the target and type
+ * of the reference link.
+ *
+ * Reference text elements enable navigation between related documentation
+ * sections, supporting both internal references within the documentation
+ * set and external references to other documentation sources or websites.
+ *
+ * @public
+ */
 export class AbstractDocRefTextType extends AbstractDataModelBase {
     // Any sequence of them.
     // children: Array<string | DocTitleCmdGroup> = []
-    // Mandatory attributes.
+    /**
+     * Mandatory reference identifier for the linked element.
+     *
+     * @remarks
+     * Specifies the unique identifier of the referenced documentation element,
+     * enabling precise linking to specific functions, classes, or other
+     * documented entities within the documentation set.
+     */
     refid = '';
+    /**
+     * Mandatory reference kind specifying the type of referenced element.
+     *
+     * @remarks
+     * Indicates the type of element being referenced such as 'compound',
+     * 'member', or other entity types, helping the documentation system
+     * resolve and format the reference appropriately.
+     */
     kindref = ''; // DoxRefKind
-    // Optional attributes.
+    /**
+     * Optional external reference attribute for external links.
+     *
+     * @remarks
+     * Specifies external documentation sources when the reference points to
+     * elements outside the current documentation set, enabling links to
+     * external APIs, libraries, or documentation websites.
+     */
     external;
+    /**
+     * Constructs an AbstractDocRefTextType from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the reference data
+     * @param elementName - The XML element name for identification purposes
+     *
+     * @remarks
+     * This constructor processes reference text elements by extracting mixed
+     * content and reference attributes, enabling proper cross-reference
+     * functionality within documentation generation workflows.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -4796,14 +5936,80 @@ export class RefDataModel extends AbstractDocRefTextType {
 //   <xsd:attribute name="cols" type="xsd:integer" />
 //   <xsd:attribute name="width" type="xsd:string" /> // WARNING: optional
 // </xsd:complexType>
+/**
+ * Abstract base class for table elements within documentation content.
+ *
+ * @remarks
+ * Represents tabular data structures that organise content into rows and
+ * columns, providing structured presentation of information within
+ * documentation. This abstract class manages table structure including
+ * optional captions, table rows, and sizing attributes that control table
+ * appearance and layout within generated documentation.
+ *
+ * Tables support complex content organisation enabling clear presentation
+ * of structured data, comparison information, and technical specifications
+ * that enhance documentation readability and user comprehension.
+ *
+ * @public
+ */
 export class AbstractDocTableType extends AbstractDataModelBase {
+    /**
+     * Optional caption element for the table.
+     *
+     * @remarks
+     * Contains descriptive text that provides context or explanation for the
+     * table content, typically displayed above or below the table in the
+     * rendered documentation output.
+     */
     caption = undefined;
+    /**
+     * Optional array of table rows containing table data.
+     *
+     * @remarks
+     * Contains all row elements that constitute the table content, maintaining
+     * order and structure for proper table rendering within documentation
+     * generation workflows.
+     */
     rows = undefined;
-    // Mandatory attributes.
+    /**
+     * Mandatory number of rows in the table.
+     *
+     * @remarks
+     * Specifies the total number of rows that the table should contain,
+     * enabling proper table structure validation and layout calculation
+     * during documentation generation.
+     */
     rowsCount = NaN;
+    /**
+     * Mandatory number of columns in the table.
+     *
+     * @remarks
+     * Specifies the total number of columns that the table should contain,
+     * enabling proper table structure validation and layout calculation
+     * during documentation generation.
+     */
     colsCount = NaN;
-    // Optional
+    /**
+     * Optional width specification for the table.
+     *
+     * @remarks
+     * Defines the table width using CSS-style values such as percentages,
+     * pixels, or other units, allowing control over table presentation and
+     * layout within the documentation output.
+     */
     width;
+    /**
+     * Constructs an AbstractDocTableType from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the table data
+     * @param elementName - The XML element name for identification purposes
+     *
+     * @remarks
+     * This constructor processes table elements by extracting caption, rows,
+     * and sizing attributes that define table structure and appearance within
+     * documentation generation workflows.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -4870,9 +6076,44 @@ export class DocTableDataModel extends AbstractDocTableType {
 //     <xsd:element name="entry" type="docEntryType" minOccurs="0" maxOccurs="unbounded" />
 //   </xsd:sequence>
 // </xsd:complexType>
+/**
+ * Abstract base class for table row elements within table structures.
+ *
+ * @remarks
+ * Represents individual rows within table elements, containing a sequence
+ * of entry elements that constitute the row's cell content. This abstract
+ * class provides structure for table row processing whilst maintaining
+ * flexibility for different row types and table configurations within
+ * documentation content.
+ *
+ * Table rows organise content horizontally across table columns, enabling
+ * structured data presentation that supports complex information layouts
+ * and enhances documentation readability through clear data organisation.
+ *
+ * @public
+ */
 export class AbstractDocRowType extends AbstractDataModelBase {
-    // Optional elements.
+    /**
+     * Optional array of entry elements constituting the row content.
+     *
+     * @remarks
+     * Contains the individual cell entries that make up this table row,
+     * maintaining order and structure for proper table rendering within
+     * documentation generation workflows.
+     */
     entries;
+    /**
+     * Constructs an AbstractDocRowType from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the row data
+     * @param elementName - The XML element name for identification purposes
+     *
+     * @remarks
+     * This constructor processes table row elements by extracting entry
+     * elements that define the row's cell content within documentation
+     * generation workflows.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -4922,17 +6163,108 @@ export class DocRowDataModel extends AbstractDocRowType {
 //   <xsd:attribute name="class" type="xsd:string" /> // WARNING: optional
 //   <xsd:anyAttribute processContents="skip"/>
 // </xsd:complexType>
+/**
+ * Abstract base class for table entry (cell) elements within table rows.
+ *
+ * @remarks
+ * Represents individual cells within table rows, containing paragraph
+ * content and various attributes that control cell presentation and layout.
+ * This abstract class provides comprehensive support for table cell
+ * functionality including header designation, spanning, alignment, and
+ * styling attributes that enable rich table formatting within documentation.
+ *
+ * Table entries support complex content organisation through paragraph
+ * elements and flexible presentation through layout attributes, enabling
+ * professional table design that enhances documentation clarity and
+ * visual appeal.
+ *
+ * @public
+ */
 export class AbstractDocEntryType extends AbstractDataModelBase {
-    // Optional elements.
+    /**
+     * Optional array of paragraph elements within this table entry.
+     *
+     * @remarks
+     * Contains the paragraph content that constitutes the cell content,
+     * supporting rich text formatting and nested elements within table
+     * cells for comprehensive documentation presentation.
+     */
     paras;
-    // Mandatory attributes.
+    /**
+     * Boolean flag indicating whether this entry is a table header.
+     *
+     * @remarks
+     * Determines whether this cell should be treated as a header cell,
+     * affecting its visual presentation and semantic meaning within the
+     * table structure for improved accessibility and styling.
+     */
     thead = false;
+    /**
+     * Optional column span value for cell spanning.
+     *
+     * @remarks
+     * Specifies the number of columns this cell should span horizontally,
+     * enabling complex table layouts with merged cells that improve data
+     * organisation and presentation clarity.
+     */
     colspan;
+    /**
+     * Optional row span value for cell spanning.
+     *
+     * @remarks
+     * Specifies the number of rows this cell should span vertically,
+     * enabling complex table layouts with merged cells that improve data
+     * organisation and presentation clarity.
+     */
     rowspan;
+    /**
+     * Optional horizontal alignment specification for cell content.
+     *
+     * @remarks
+     * Controls the horizontal alignment of content within the cell such as
+     * 'left', 'center', 'right', or 'justify', enabling precise content
+     * positioning for improved table presentation.
+     */
     align;
+    /**
+     * Optional vertical alignment specification for cell content.
+     *
+     * @remarks
+     * Controls the vertical alignment of content within the cell such as
+     * 'top', 'middle', or 'bottom', enabling precise content positioning
+     * for improved table presentation.
+     */
     valign;
+    /**
+     * Optional width specification for the table entry.
+     *
+     * @remarks
+     * Defines the cell width using CSS-style values such as percentages,
+     * pixels, or other units, allowing precise control over table column
+     * sizing and layout appearance.
+     */
     width;
+    /**
+     * Optional CSS class specification for styling purposes.
+     *
+     * @remarks
+     * Provides CSS class names for custom styling of table cells, enabling
+     * enhanced visual presentation and consistent styling across
+     * documentation output.
+     */
     classs;
+    /**
+     * Constructs an AbstractDocEntryType from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the entry data
+     * @param elementName - The XML element name for identification purposes
+     *
+     * @remarks
+     * This constructor processes table entry elements by extracting paragraph
+     * content and layout attributes that define cell structure and appearance
+     * within documentation generation workflows.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -5007,11 +6339,47 @@ export class DocEntryDataModel extends AbstractDocEntryType {
 //   <xsd:group ref="docTitleCmdGroup" minOccurs="0" maxOccurs="unbounded" />
 //   <xsd:attribute name="id" type="xsd:string" />
 // </xsd:complexType>
+/**
+ * Abstract base class for caption elements within documentation content.
+ *
+ * @remarks
+ * Represents caption elements that provide descriptive text for tables,
+ * figures, images, and other content elements within documentation.
+ * This abstract class handles mixed content including text and formatting
+ * commands alongside an identifier attribute for cross-referencing and
+ * linking purposes.
+ *
+ * Captions enhance content accessibility and understanding by providing
+ * descriptive context for visual and structured elements, supporting
+ * comprehensive documentation that improves user comprehension and
+ * content navigation.
+ *
+ * @public
+ */
 export class AbstractDocCaptionType extends AbstractDataModelBase {
     // Any sequence of them.
     // children: Array<string | DocTitleCmdGroup> = []
-    // Mandatory attributes.
+    /**
+     * Mandatory identifier for the caption element.
+     *
+     * @remarks
+     * Specifies the unique identifier for this caption element, enabling
+     * cross-referencing and linking within documentation generation
+     * workflows and supporting proper caption association with content.
+     */
     id = '';
+    /**
+     * Constructs an AbstractDocCaptionType from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the caption data
+     * @param elementName - The XML element name for identification purposes
+     *
+     * @remarks
+     * This constructor processes caption elements by extracting mixed content
+     * including text and formatting commands alongside the mandatory identifier
+     * attribute within documentation generation workflows.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -5130,19 +6498,105 @@ export class HeadingDataModel extends AbstractDocHeadingType {
 //   </xsd:restriction>
 // </xsd:simpleType>
 /**
+ * Abstract base class for image elements within documentation content.
+ *
+ * @remarks
+ * Represents image elements that can be embedded within documentation
+ * descriptions and content blocks. This implementation processes Doxygen's
+ * image elements, which support multiple output formats (HTML, LaTeX,
+ * DocBook, RTF, XML) and provide comprehensive image metadata including
+ * dimensions, captions, alternative text, and inline positioning.
+ *
+ * Image elements support mixed content with text and formatting commands,
+ * allowing for rich image descriptions and captions. The class tracks HTML
+ * images specifically for asset copying during documentation generation.
+ *
  * @public
  */
 export class AbstractDocImageType extends AbstractDataModelBase {
     // Any sequence of them.
     // children: Array<string | DocTitleCmdGroup> = []
-    // Optional attributes.
+    /**
+     * Output format type for the image.
+     *
+     * @remarks
+     * Specifies the target output format for the image, such as 'html',
+     * 'latex', 'docbook', 'rtf', or 'xml'. This determines how the image
+     * should be processed and rendered in different documentation outputs.
+     */
     type;
+    /**
+     * Name or path of the image file.
+     *
+     * @remarks
+     * Contains the filename or path to the image resource. For HTML images,
+     * this typically references files that need to be copied to the output
+     * folder during documentation generation.
+     */
     name;
+    /**
+     * Width specification for the image.
+     *
+     * @remarks
+     * Specifies the desired width for the image rendering. The format and
+     * units depend on the target output format and may include CSS-style
+     * dimensions or format-specific measurements.
+     */
     width;
+    /**
+     * Height specification for the image.
+     *
+     * @remarks
+     * Specifies the desired height for the image rendering. The format and
+     * units depend on the target output format and may include CSS-style
+     * dimensions or format-specific measurements.
+     */
     height;
+    /**
+     * Alternative text for accessibility and fallback purposes.
+     *
+     * @remarks
+     * Provides descriptive text for the image that can be used by screen
+     * readers and displayed when the image cannot be loaded. This supports
+     * accessibility requirements and fallback presentation.
+     */
     alt;
+    /**
+     * Inline positioning flag for the image.
+     *
+     * @remarks
+     * Determines whether the image should be rendered inline with text
+     * content or as a block-level element. Inline images flow with text
+     * whilst block images create separate content sections.
+     */
     inline;
+    /**
+     * Caption text for the image.
+     *
+     * @remarks
+     * Provides descriptive caption text that accompanies the image display.
+     * Captions typically appear below or adjacent to the image and provide
+     * additional context or explanation for the visual content.
+     */
     caption;
+    /**
+     * Constructs an AbstractDocImageType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the image data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes image elements by extracting all optional
+     * attributes including type, name, dimensions, alternative text, inline
+     * positioning, and caption information. For HTML images with local file
+     * references, the image is registered with the parser for asset tracking
+     * during documentation generation.
+     *
+     * The implementation also processes any mixed content within the image
+     * element, including text and formatting commands that may be part of
+     * the image description or caption.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -5198,7 +6652,34 @@ export class AbstractDocImageType extends AbstractDataModelBase {
     }
 }
 // <xsd:element name="image" type="docImageType" />
+/**
+ * Data model for image elements within documentation content.
+ *
+ * @remarks
+ * Represents image elements that embed visual content within documentation
+ * descriptions and content blocks. This implementation processes Doxygen's
+ * image elements, providing support for multiple output formats and
+ * comprehensive image metadata management.
+ *
+ * Images can include formatting content, captions, and metadata attributes
+ * that control their presentation across different documentation outputs.
+ * The class ensures proper asset tracking for HTML images during the
+ * documentation generation process.
+ *
+ * @public
+ */
 export class ImageDataModel extends AbstractDocImageType {
+    /**
+     * Constructs an ImageDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the image data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocImageType whilst
+     * identifying the element as 'image' for proper image processing and
+     * asset management within documentation generation workflows.
+     */
     constructor(xml, element) {
         super(xml, element, 'image');
     }
@@ -5250,11 +6731,55 @@ export class ImageDataModel extends AbstractDocImageType {
 //   </xsd:sequence>
 //   <xsd:attribute name="kind" type="DoxParamListKind" />
 // </xsd:complexType>
+/**
+ * Abstract base class for parameter list elements within documentation.
+ *
+ * @remarks
+ * Represents parameter lists that document function and method parameters,
+ * return values, exceptions, and other parameter-related information.
+ * This abstract class manages collections of parameter items and their
+ * associated metadata, providing structured documentation for function
+ * signatures and parameter descriptions.
+ *
+ * Parameter lists support various parameter documentation types including
+ * input parameters, output parameters, return values, and exceptions,
+ * enabling comprehensive function documentation that enhances API
+ * understanding and usage.
+ *
+ * @public
+ */
 export class AbstractDocParamListType extends AbstractDataModelBase {
-    // Optional elements.
+    /**
+     * Optional array of parameter items within this parameter list.
+     *
+     * @remarks
+     * Contains individual parameter item elements that document specific
+     * parameters, return values, or exceptions associated with functions
+     * and methods within the documentation.
+     */
     parameterItems;
-    // Mandatory attributes.
+    /**
+     * Mandatory kind attribute specifying the parameter list type.
+     *
+     * @remarks
+     * Specifies the type of parameter list such as 'param', 'retval',
+     * 'exception', 'templateparam', or other parameter documentation
+     * types that determine how the parameter list should be interpreted
+     * and formatted in documentation output.
+     */
     kind = '';
+    /**
+     * Constructs an AbstractDocParamListType from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the parameter list data
+     * @param elementName - The XML element name for identification purposes
+     *
+     * @remarks
+     * This constructor processes parameter list elements by extracting
+     * parameter items and the mandatory kind attribute that defines the
+     * parameter list type within documentation generation workflows.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -5497,12 +7022,62 @@ export class ParameterNameDataModel extends AbstractDocParamName {
 //   </xsd:sequence>
 //   <xsd:attribute name="id" type="xsd:string" />
 // </xsd:complexType>
+/**
+ * Abstract base class for cross-reference section elements.
+ *
+ * @remarks
+ * Represents cross-reference sections that provide links and references to
+ * related documentation elements, enabling navigation between connected
+ * content areas. This abstract class manages cross-reference sections
+ * including optional titles and mandatory descriptions that provide context
+ * and detail for the referenced content.
+ *
+ * Cross-reference sections enhance documentation usability by establishing
+ * clear relationships between related topics, supporting comprehensive
+ * navigation and content discovery within large documentation sets.
+ *
+ * @public
+ */
 export class AbstractDocXRefSectType extends AbstractDataModelBase {
-    // Mandatory elements.
+    /**
+     * Optional title for the cross-reference section.
+     *
+     * @remarks
+     * Contains the title text for the cross-reference section when present,
+     * providing descriptive context for the referenced content and improving
+     * section identification within documentation output.
+     */
     xreftitle;
+    /**
+     * Mandatory description for the cross-reference section.
+     *
+     * @remarks
+     * Contains detailed descriptive content for the cross-reference section,
+     * providing comprehensive information about the referenced content and
+     * its relationship to the current documentation context.
+     */
     xrefdescription;
-    // Mandatory attributes.
+    /**
+     * Mandatory identifier for the cross-reference section.
+     *
+     * @remarks
+     * Specifies the unique identifier for this cross-reference section,
+     * enabling precise linking and referencing within documentation
+     * generation workflows and cross-reference resolution.
+     */
     id = '';
+    /**
+     * Constructs an AbstractDocXRefSectType from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the cross-reference data
+     * @param elementName - The XML element name for identification purposes
+     *
+     * @remarks
+     * This constructor processes cross-reference section elements by extracting
+     * title, description, and identifier information that defines cross-reference
+     * relationships within documentation generation workflows.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element,
@@ -5626,9 +7201,53 @@ export class AbstractDocEmptyType extends AbstractDataModelBase {
 //   <xsd:attribute name="name" type="xsd:string"/>
 //   <xsd:attribute name="unicode" type="xsd:string"/>
 // </xsd:complexType>
+/**
+ * Abstract base class for emoji elements within documentation content.
+ *
+ * @remarks
+ * Represents emoji elements that can be embedded within documentation
+ * content to enhance visual communication and expression. This abstract
+ * class manages emoji data including both human-readable names and
+ * Unicode representations that enable consistent emoji rendering across
+ * different documentation output formats and platforms.
+ *
+ * Emoji elements support modern documentation practices by enabling
+ * expressive visual communication that can improve user engagement and
+ * content accessibility in appropriate documentation contexts.
+ *
+ * @public
+ */
 export class AbstractEmojiType extends AbstractDataModelBase {
+    /**
+     * The human-readable name identifier for the emoji.
+     *
+     * @remarks
+     * Specifies the emoji name using standard emoji naming conventions,
+     * enabling consistent emoji identification and providing fallback
+     * representation when Unicode rendering is not available.
+     */
     name = '';
+    /**
+     * The Unicode code point representation for the emoji.
+     *
+     * @remarks
+     * Contains the Unicode code point or sequence that defines the emoji
+     * character, enabling proper emoji rendering in Unicode-capable
+     * documentation output formats and systems.
+     */
     unicode = '';
+    /**
+     * Constructs an AbstractEmojiType from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the emoji data
+     * @param elementName - The XML element name for identification purposes
+     *
+     * @remarks
+     * This constructor processes emoji elements by extracting name and Unicode
+     * attributes that define emoji representation within documentation
+     * generation workflows.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -5673,9 +7292,34 @@ export class EmojiDataModel extends AbstractEmojiType {
 // <xsd:element name="xrefdescription" type="descriptionType" />
 // <xsd:element name="parameterdescription" type="descriptionType" />
 /**
+ * Data model for brief description elements within documentation.
+ *
+ * @remarks
+ * Represents brief description elements that provide concise summary
+ * content for entities. This implementation processes Doxygen's
+ * briefdescription elements, which contain short descriptive content
+ * used for entity summaries, overviews, and quick reference information
+ * within documentation structures.
+ *
+ * Brief descriptions are typically displayed in listings, summaries,
+ * and overview sections to provide immediate context about documented
+ * entities without requiring full detailed descriptions.
+ *
  * @public
  */
 export class BriefDescriptionDataModel extends AbstractDescriptionType {
+    /**
+     * Constructs a BriefDescriptionDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the brief description
+     *   data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDescriptionType whilst
+     * identifying the element as 'briefdescription' for concise summary
+     * content processing and documentation organisation.
+     */
     constructor(xml, element) {
         super(xml, element, 'briefdescription');
     }
@@ -5683,33 +7327,142 @@ export class BriefDescriptionDataModel extends AbstractDescriptionType {
 /**
  * @public
  */
+/**
+ * Data model for detailed description elements within documentation.
+ *
+ * @remarks
+ * Represents detailed description elements that provide comprehensive
+ * documentation content for entities. This implementation processes
+ * Doxygen's detaileddescription elements, which contain extensive
+ * descriptive content including paragraphs, sections, lists, and
+ * other rich documentation structures.
+ *
+ * @public
+ */
 export class DetailedDescriptionDataModel extends AbstractDescriptionType {
+    /**
+     * Constructs a DetailedDescriptionDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the detailed
+     *   description data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDescriptionType whilst
+     * identifying the element as 'detaileddescription' for comprehensive
+     * content processing and documentation organisation.
+     */
     constructor(xml, element) {
         super(xml, element, 'detaileddescription');
     }
 }
 /**
+ * Data model for in-body description elements within documentation.
+ *
+ * @remarks
+ * Represents in-body description elements that provide documentation
+ * content embedded within source code bodies. This implementation
+ * processes Doxygen's inbodydescription elements for documentation
+ * that appears inline within code implementations.
+ *
  * @public
  */
 export class InbodyDescriptionDataModel extends AbstractDescriptionType {
+    /**
+     * Constructs an InbodyDescriptionDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the in-body
+     *   description data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDescriptionType whilst
+     * identifying the element as 'inbodydescription' for inline documentation
+     * content processing within code implementations.
+     */
     constructor(xml, element) {
         super(xml, element, 'inbodydescription');
     }
 }
 /**
+ * Data model for general description elements within documentation.
+ *
+ * @remarks
+ * Represents general description elements that provide standard documentation
+ * content for entities. This implementation processes Doxygen's description
+ * elements, which contain descriptive content including paragraphs and
+ * other documentation structures for general-purpose descriptions.
+ *
  * @public
  */
 export class DescriptionDataModel extends AbstractDescriptionType {
+    /**
+     * Constructs a DescriptionDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the description data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDescriptionType whilst
+     * identifying the element as 'description' for general-purpose description
+     * content processing and documentation organisation.
+     */
     constructor(xml, element) {
         super(xml, element, 'description');
     }
 }
+/**
+ * Data model for cross-reference description elements within documentation.
+ *
+ * @remarks
+ * Represents cross-reference description elements that provide descriptive
+ * content for cross-references and related sections. This implementation
+ * processes Doxygen's xrefdescription elements for documentation content
+ * associated with cross-reference sections and related material.
+ *
+ * @public
+ */
 export class XrefDescriptionDataModel extends AbstractDescriptionType {
+    /**
+     * Constructs an XrefDescriptionDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the cross-reference
+     *   description data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDescriptionType whilst
+     * identifying the element as 'xrefdescription' for cross-reference section
+     * content processing and related documentation organisation.
+     */
     constructor(xml, element) {
         super(xml, element, 'xrefdescription');
     }
 }
+/**
+ * Data model for parameter description elements within documentation.
+ *
+ * @remarks
+ * Represents parameter description elements that provide descriptive content
+ * for function and method parameters. This implementation processes Doxygen's
+ * parameterdescription elements for parameter documentation within parameter
+ * lists and function descriptions.
+ *
+ * @public
+ */
 export class ParameterDescriptionDataModel extends AbstractDescriptionType {
+    /**
+     * Constructs a ParameterDescriptionDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the parameter
+     *   description data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDescriptionType whilst
+     * identifying the element as 'parameterdescription' for parameter-specific
+     * documentation content processing within function documentation.
+     */
     constructor(xml, element) {
         super(xml, element, 'parameterdescription');
     }
@@ -5730,84 +7483,431 @@ export class ParameterDescriptionDataModel extends AbstractDescriptionType {
 // <xsd:element name="sect6" type="docSect6Type" minOccurs="0" maxOccurs="unbounded" />
 // <xsd:element name="title" type="docTitleType" minOccurs="0" />
 // <xsd:element name="term" type="docTitleType" />
+/**
+ * Data model for internal documentation section elements.
+ *
+ * @remarks
+ * Represents internal documentation sections that contain content marked
+ * as internal or implementation-specific within documentation. This
+ * implementation processes Doxygen's internal elements for organising
+ * content that is typically hidden from public documentation views
+ * but retained for developer reference.
+ *
+ * @public
+ */
 export class InternalDataModel extends AbstractDocInternalType {
+    /**
+     * Constructs an InternalDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the internal section
+     *   data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocInternalType to
+     * handle internal section processing whilst identifying the element as
+     * 'internal' for proper content organisation and visibility control.
+     */
     constructor(xml, element) {
         super(xml, element, 'internal');
     }
 }
+/**
+ * Data model for first-level internal documentation section elements.
+ *
+ * @remarks
+ * Represents internal documentation sections at the first hierarchical level
+ * within section structures. This implementation processes Doxygen's internal
+ * elements that appear within first-level sections, providing organised
+ * internal content that is typically excluded from public documentation.
+ *
+ * @public
+ */
 export class InternalS1DataModel extends AbstractDocInternalS1Type {
+    /**
+     * Constructs an InternalS1DataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the internal S1
+     *   section data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocInternalS1Type whilst
+     * identifying the element as 'internal' for first-level internal content.
+     */
     constructor(xml, element) {
         super(xml, element, 'internal');
     }
 }
+/**
+ * Data model for second-level internal documentation section elements.
+ *
+ * @remarks
+ * Represents internal documentation sections at the second hierarchical level
+ * within section structures. This implementation processes internal content
+ * that appears within second-level sections for detailed internal documentation
+ * organisation.
+ *
+ * @public
+ */
 export class InternalS2DataModel extends AbstractDocInternalS2Type {
+    /**
+     * Constructs an InternalS2DataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the internal S2
+     *   section data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocInternalS2Type whilst
+     * identifying the element as 'internal' for second-level internal content.
+     */
     constructor(xml, element) {
         super(xml, element, 'internal');
     }
 }
+/**
+ * Data model for third-level internal documentation section elements.
+ *
+ * @remarks
+ * Represents internal documentation sections at the third hierarchical level
+ * for detailed internal content organisation within deeply nested section
+ * structures.
+ *
+ * @public
+ */
 export class InternalS3DataModel extends AbstractDocInternalS3Type {
+    /**
+     * Constructs an InternalS3DataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the internal S3
+     *   section data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocInternalS3Type whilst
+     * identifying the element as 'internal' for third-level internal content.
+     */
     constructor(xml, element) {
         super(xml, element, 'internal');
     }
 }
+/**
+ * Data model for fourth-level internal documentation section elements.
+ *
+ * @remarks
+ * Represents internal documentation sections at the fourth hierarchical level
+ * for very detailed internal content organisation within deeply nested
+ * documentation structures.
+ *
+ * @public
+ */
 export class InternalS4DataModel extends AbstractDocInternalS4Type {
+    /**
+     * Constructs an InternalS4DataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the internal S4
+     *   section data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocInternalS4Type whilst
+     * identifying the element as 'internal' for fourth-level internal content.
+     */
     constructor(xml, element) {
         super(xml, element, 'internal');
     }
 }
+/**
+ * Data model for fifth-level internal documentation section elements.
+ *
+ * @remarks
+ * Represents internal documentation sections at the fifth hierarchical level
+ * for extremely detailed internal content organisation within complex
+ * documentation hierarchies.
+ *
+ * @public
+ */
 export class InternalS5DataModel extends AbstractDocInternalS5Type {
+    /**
+     * Constructs an InternalS5DataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the internal S5
+     *   section data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocInternalS5Type whilst
+     * identifying the element as 'internal' for fifth-level internal content.
+     */
     constructor(xml, element) {
         super(xml, element, 'internal');
     }
 }
+/**
+ * Data model for sixth-level internal documentation section elements.
+ *
+ * @remarks
+ * Represents internal documentation sections at the deepest hierarchical level
+ * supported by the schema for comprehensive internal content organisation
+ * within complex documentation structures.
+ *
+ * @public
+ */
 export class InternalS6DataModel extends AbstractDocInternalS6Type {
+    /**
+     * Constructs an InternalS6DataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the internal S6
+     *   section data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocInternalS6Type whilst
+     * identifying the element as 'internal' for sixth-level internal content.
+     */
     constructor(xml, element) {
         super(xml, element, 'internal');
     }
 }
+/**
+ * Data model for first-level section elements within documentation.
+ *
+ * @remarks
+ * Represents level-1 sections that form the primary organisational structure
+ * within documentation descriptions. This implementation processes Doxygen's
+ * sect1 elements, which contain titles, paragraphs, internal sections, and
+ * nested level-2 sections, providing the foundation for hierarchical
+ * documentation organisation.
+ *
+ * @public
+ */
 export class Sect1DataModel extends AbstractDocSect1Type {
+    /**
+     * Constructs a Sect1DataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the sect1 data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocSect1Type to handle
+     * the standard first-level section processing whilst specifically
+     * identifying the element as a 'sect1' type for proper XML schema compliance.
+     */
     constructor(xml, element) {
         super(xml, element, 'sect1');
     }
 }
+/**
+ * Data model for second-level section elements within documentation.
+ *
+ * @remarks
+ * Represents level-2 sections that provide additional organisational depth
+ * within first-level sections. This implementation processes Doxygen's
+ * sect2 elements, which contain titles, paragraphs, internal sections, and
+ * nested level-3 sections, enabling detailed content structuring within
+ * the documentation hierarchy.
+ *
+ * @public
+ */
 export class Sect2DataModel extends AbstractDocSect2Type {
+    /**
+     * Constructs a Sect2DataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the sect2 data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocSect2Type to handle
+     * the standard second-level section processing whilst specifically
+     * identifying the element as a 'sect2' type for proper XML schema compliance.
+     */
     constructor(xml, element) {
         super(xml, element, 'sect2');
     }
 }
+/**
+ * Data model for third-level section elements within documentation.
+ *
+ * @remarks
+ * Represents level-3 sections that provide detailed subsection organisation
+ * within second-level sections. This implementation processes Doxygen's
+ * sect3 elements for granular content structuring.
+ *
+ * @public
+ */
 export class Sect3DataModel extends AbstractDocSect3Type {
+    /**
+     * Constructs a Sect3DataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the sect3 data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocSect3Type to handle
+     * third-level section processing whilst identifying the element as 'sect3'.
+     */
     constructor(xml, element) {
         super(xml, element, 'sect3');
     }
 }
+/**
+ * Data model for fourth-level section elements within documentation.
+ *
+ * @remarks
+ * Represents level-4 sections for deep hierarchical content organisation.
+ * This implementation processes Doxygen's sect4 elements within the
+ * documentation structure hierarchy.
+ *
+ * @public
+ */
 export class Sect4DataModel extends AbstractDocSect4Type {
+    /**
+     * Constructs a Sect4DataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the sect4 data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocSect4Type whilst
+     * identifying the element as 'sect4' for schema compliance.
+     */
     constructor(xml, element) {
         super(xml, element, 'sect4');
     }
 }
+/**
+ * Data model for fifth-level section elements within documentation.
+ *
+ * @remarks
+ * Represents level-5 sections for very detailed content organisation.
+ * This implementation processes Doxygen's sect5 elements within deeply
+ * nested documentation structures.
+ *
+ * @public
+ */
 export class Sect5DataModel extends AbstractDocSect5Type {
+    /**
+     * Constructs a Sect5DataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the sect5 data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocSect5Type whilst
+     * identifying the element as 'sect5' for schema compliance.
+     */
     constructor(xml, element) {
         super(xml, element, 'sect5');
     }
 }
+/**
+ * Data model for sixth-level section elements within documentation.
+ *
+ * @remarks
+ * Represents the deepest level of section organisation supported by the
+ * Doxygen schema. This implementation processes Doxygen's sect6 elements
+ * for maximum hierarchical depth in documentation structures.
+ *
+ * @public
+ */
 export class Sect6DataModel extends AbstractDocSect6Type {
+    /**
+     * Constructs a Sect6DataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the sect6 data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocSect6Type whilst
+     * identifying the element as 'sect6' for schema compliance.
+     */
     constructor(xml, element) {
         super(xml, element, 'sect6');
     }
 }
+/**
+ * Data model for title elements within documentation structures.
+ *
+ * @remarks
+ * Represents title elements that provide descriptive headings for sections,
+ * tables, figures, and other documentation components. This implementation
+ * processes Doxygen's title elements, which support rich formatting and
+ * mixed content to create informative and properly styled headings.
+ *
+ * @public
+ */
 export class TitleDataModel extends AbstractDocTitleType {
+    /**
+     * Constructs a TitleDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the title data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocTitleType to handle
+     * title processing whilst identifying the element as 'title' for proper
+     * XML schema compliance.
+     */
     constructor(xml, element) {
         super(xml, element, 'title');
     }
 }
+/**
+ * Data model for term elements within definition lists.
+ *
+ * @remarks
+ * Represents term elements that provide the definition term within variable
+ * lists and definition structures. This implementation processes Doxygen's
+ * term elements, which support formatted content for creating clear and
+ * descriptive definition terms.
+ *
+ * @public
+ */
 export class TermDataModel extends AbstractDocTitleType {
+    /**
+     * Constructs a TermDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the term data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocTitleType to handle
+     * term processing whilst identifying the element as 'term' for proper
+     * XML schema compliance and definition list semantics.
+     */
     constructor(xml, element) {
         super(xml, element, 'term');
     }
 }
 // ----------------------------------------------------------------------------
 // <xsd:element name="para" type="docParaType" minOccurs="0" maxOccurs="unbounded" />
+/**
+ * Data model for paragraph elements within documentation content.
+ *
+ * @remarks
+ * Represents paragraph elements that form the fundamental content blocks
+ * within documentation structures. This implementation processes Doxygen's
+ * para elements, which contain rich mixed content including text, formatting,
+ * cross-references, lists, tables, and other documentation elements.
+ *
+ * Paragraphs serve as the primary containers for narrative content within
+ * descriptions, sections, and other documentation components.
+ *
+ * @public
+ */
 export class ParaDataModel extends AbstractDocParaType {
+    /**
+     * Constructs a ParaDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the paragraph data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocParaType to handle
+     * comprehensive paragraph content processing whilst identifying the element
+     * as 'para' for proper XML schema compliance and content organisation.
+     */
     constructor(xml, element) {
         super(xml, element, 'para');
     }
@@ -5817,87 +7917,430 @@ export class ParaDataModel extends AbstractDocParaType {
 // <xsd:element name="underline" type="docMarkupType" />
 // <xsd:element name="emphasis" type="docMarkupType" />
 // <xsd:element name="computeroutput" type="docMarkupType" />
+/**
+ * Data model for bold text formatting within documentation content.
+ *
+ * @remarks
+ * Represents bold markup elements that provide emphasis formatting for
+ * text content within documentation. This implementation processes Doxygen's
+ * bold elements, which can contain mixed content including text and other
+ * inline formatting elements to create properly emphasised content.
+ *
+ * @public
+ */
 export class BoldDataModel extends AbstractDocMarkupType {
+    /**
+     * Constructs a BoldDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the bold markup data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocMarkupType to handle
+     * markup processing whilst identifying the element as 'bold' for proper
+     * XML schema compliance and text formatting.
+     */
     constructor(xml, element) {
         super(xml, element, 'bold');
     }
 }
+/**
+ * Data model for strikethrough text formatting within documentation content.
+ *
+ * @remarks
+ * Represents strikethrough markup elements that provide strike-through
+ * formatting for text content. This implementation processes Doxygen's
+ * 's' elements for creating struck-through text within documentation.
+ *
+ * @public
+ */
 export class SDataModel extends AbstractDocMarkupType {
+    /**
+     * Constructs an SDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the strikethrough
+     *   markup data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocMarkupType whilst
+     * identifying the element as 's' for proper strikethrough formatting.
+     */
     constructor(xml, element) {
         super(xml, element, 's');
     }
 }
+/**
+ * Data model for strike-through text formatting within documentation content.
+ *
+ * @remarks
+ * Represents strike markup elements that provide explicit strike-through
+ * formatting for text content. This implementation processes Doxygen's
+ * strike elements for deprecated or crossed-out text within documentation.
+ *
+ * @public
+ */
 export class StrikeDataModel extends AbstractDocMarkupType {
+    /**
+     * Constructs a StrikeDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the strike markup data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocMarkupType whilst
+     * identifying the element as 'strike' for explicit strike-through formatting.
+     */
     constructor(xml, element) {
         super(xml, element, 'strike');
     }
 }
+/**
+ * Data model for underlined text formatting within documentation content.
+ *
+ * @remarks
+ * Represents underline markup elements that provide underline formatting
+ * for text content within documentation. This implementation processes
+ * Doxygen's underline elements for creating underlined text emphasis.
+ *
+ * @public
+ */
 export class UnderlineDataModel extends AbstractDocMarkupType {
+    /**
+     * Constructs an UnderlineDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the underline markup
+     *   data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocMarkupType whilst
+     * identifying the element as 'underline' for proper underline formatting.
+     */
     constructor(xml, element) {
         super(xml, element, 'underline');
     }
 }
+/**
+ * Data model for emphasised text formatting within documentation content.
+ *
+ * @remarks
+ * Represents emphasis markup elements that provide italicised formatting
+ * for text content within documentation. This implementation processes
+ * Doxygen's emphasis elements for creating emphasised text, typically
+ * rendered in italics to provide subtle content highlighting.
+ *
+ * @public
+ */
 export class EmphasisDataModel extends AbstractDocMarkupType {
+    /**
+     * Constructs an EmphasisDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the emphasis markup data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocMarkupType whilst
+     * identifying the element as 'emphasis' for proper italicised formatting.
+     */
     constructor(xml, element) {
         super(xml, element, 'emphasis');
     }
 }
+/**
+ * Data model for computer output text formatting within documentation content.
+ *
+ * @remarks
+ * Represents computer output markup elements that provide monospace formatting
+ * for code, filenames, and computer-generated text within documentation.
+ * This implementation processes Doxygen's computeroutput elements for
+ * displaying code fragments and technical terms in monospace font.
+ *
+ * @public
+ */
 export class ComputerOutputDataModel extends AbstractDocMarkupType {
+    /**
+     * Constructs a ComputerOutputDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the computer output
+     *   markup data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocMarkupType whilst
+     * identifying the element as 'computeroutput' for monospace formatting.
+     */
     constructor(xml, element) {
         super(xml, element, 'computeroutput');
     }
 }
+/**
+ * Data model for subscript text formatting within documentation content.
+ *
+ * @remarks
+ * Represents subscript markup elements that provide subscript formatting
+ * for mathematical expressions and chemical formulae within documentation.
+ * This implementation processes Doxygen's subscript elements for proper
+ * scientific notation display.
+ *
+ * @public
+ */
 export class SubscriptDataModel extends AbstractDocMarkupType {
+    /**
+     * Constructs a SubscriptDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the subscript markup
+     *   data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocMarkupType whilst
+     * identifying the element as 'subscript' for proper subscript formatting.
+     */
     constructor(xml, element) {
         super(xml, element, 'subscript');
     }
 }
+/**
+ * Data model for superscript text formatting within documentation content.
+ *
+ * @remarks
+ * Represents superscript markup elements that provide superscript formatting
+ * for mathematical expressions, footnotes, and ordinal numbers within
+ * documentation. This implementation processes Doxygen's superscript elements
+ * for proper scientific and mathematical notation display.
+ *
+ * @public
+ */
 export class SuperscriptDataModel extends AbstractDocMarkupType {
+    /**
+     * Constructs a SuperscriptDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the superscript
+     *   markup data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocMarkupType whilst
+     * identifying the element as 'superscript' for proper superscript formatting.
+     */
     constructor(xml, element) {
         super(xml, element, 'superscript');
     }
 }
+/**
+ * Data model for centred text formatting within documentation content.
+ *
+ * @remarks
+ * Represents centre alignment markup elements that provide centred formatting
+ * for text content within documentation. This implementation processes
+ * Doxygen's center elements for creating centred text blocks and headings.
+ *
+ * @public
+ */
 export class CenterDataModel extends AbstractDocMarkupType {
+    /**
+     * Constructs a CenterDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the centre markup data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocMarkupType whilst
+     * identifying the element as 'center' for proper centred alignment.
+     */
     constructor(xml, element) {
         super(xml, element, 'center');
     }
 }
+/**
+ * Data model for small text formatting within documentation content.
+ *
+ * @remarks
+ * Represents small text markup elements that provide reduced font size
+ * formatting for fine print, footnotes, and secondary information within
+ * documentation. This implementation processes Doxygen's small elements
+ * for creating properly sized text content.
+ *
+ * @public
+ */
 export class SmallDataModel extends AbstractDocMarkupType {
+    /**
+     * Constructs a SmallDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the small text
+     *   markup data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocMarkupType whilst
+     * identifying the element as 'small' for reduced font size formatting.
+     */
     constructor(xml, element) {
         super(xml, element, 'small');
     }
 }
+/**
+ * Data model for citation text formatting within documentation content.
+ *
+ * @remarks
+ * Represents citation markup elements that provide proper formatting for
+ * bibliographic references and citations within documentation. This
+ * implementation processes Doxygen's cite elements for creating properly
+ * formatted citation references.
+ *
+ * @public
+ */
 export class CiteDataModel extends AbstractDocMarkupType {
+    /**
+     * Constructs a CiteDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the citation markup data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocMarkupType whilst
+     * identifying the element as 'cite' for proper citation formatting.
+     */
     constructor(xml, element) {
         super(xml, element, 'cite');
     }
 }
+/**
+ * Data model for deleted text formatting within documentation content.
+ *
+ * @remarks
+ * Represents deleted text markup elements that indicate content removal
+ * or deprecation within documentation. This implementation processes
+ * Doxygen's del elements for marking text as deleted or removed.
+ *
+ * @public
+ */
 export class DelDataModel extends AbstractDocMarkupType {
+    /**
+     * Constructs a DelDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the deleted text
+     *   markup data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocMarkupType whilst
+     * identifying the element as 'del' for deleted text formatting.
+     */
     constructor(xml, element) {
         super(xml, element, 'del');
     }
 }
+/**
+ * Data model for inserted text formatting within documentation content.
+ *
+ * @remarks
+ * Represents inserted text markup elements that indicate content addition
+ * or new material within documentation. This implementation processes
+ * Doxygen's ins elements for marking text as newly inserted or added.
+ *
+ * @public
+ */
 export class InsDataModel extends AbstractDocMarkupType {
+    /**
+     * Constructs an InsDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the inserted text
+     *   markup data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocMarkupType whilst
+     * identifying the element as 'ins' for inserted text formatting.
+     */
     constructor(xml, element) {
         super(xml, element, 'ins');
     }
 }
 // ----------------------------------------------------------------------------
 // <xsd:element name="simplesect" type="docSimpleSectType" />
+/**
+ * Data model for simple section elements within documentation.
+ *
+ * @remarks
+ * Represents simple sections that provide structured content organisation
+ * with specific section types such as 'note', 'warning', 'see', 'return',
+ * and others. This implementation processes Doxygen's simplesect elements,
+ * which contain typed content blocks for common documentation patterns
+ * like notes, warnings, and cross-references.
+ *
+ * @public
+ */
 export class SimpleSectDataModel extends AbstractDocSimpleSectType {
+    /**
+     * Constructs a SimpleSectDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the simplesect data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocSimpleSectType to
+     * handle simple section processing whilst identifying the element as
+     * 'simplesect' for proper XML schema compliance and section type handling.
+     */
     constructor(xml, element) {
         super(xml, element, 'simplesect');
     }
 }
 // ----------------------------------------------------------------------------
 // <xsd:element name="itemizedlist" type="docListType" />
+/**
+ * Data model for itemised list elements within documentation content.
+ *
+ * @remarks
+ * Represents itemised (bulleted) list elements that provide unordered list
+ * structures within documentation. This implementation processes Doxygen's
+ * itemizedlist elements, which contain list items for creating bulleted
+ * lists with various marker styles and nested list support.
+ *
+ * @public
+ */
 export class ItemizedListDataModel extends AbstractDocListType {
+    /**
+     * Constructs an ItemizedListDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the itemised list data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocListType to handle
+     * list processing whilst identifying the element as 'itemizedlist' for
+     * proper bulleted list formatting and structure.
+     */
     constructor(xml, element) {
         super(xml, element, 'itemizedlist');
     }
 }
 // <xsd:element name="orderedlist" type="docListType" />
+/**
+ * Data model for ordered list elements within documentation content.
+ *
+ * @remarks
+ * Represents ordered (numbered) list elements that provide sequential list
+ * structures within documentation. This implementation processes Doxygen's
+ * orderedlist elements, which contain list items for creating numbered
+ * lists with various numbering styles and nested list support.
+ *
+ * @public
+ */
 export class OrderedListDataModel extends AbstractDocListType {
+    /**
+     * Constructs an OrderedListDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the ordered list data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocListType to handle
+     * list processing whilst identifying the element as 'orderedlist' for
+     * proper numbered list formatting and structure.
+     */
     constructor(xml, element) {
         super(xml, element, 'orderedlist');
     }
@@ -5905,30 +8348,143 @@ export class OrderedListDataModel extends AbstractDocListType {
 // ----------------------------------------------------------------------------
 // <xsd:element name="linebreak" type="docEmptyType" />
 // <xsd:element name="hruler" type="docEmptyType" />
+/**
+ * Data model for line break elements within documentation content.
+ *
+ * @remarks
+ * Represents line break elements that provide explicit line breaks within
+ * documentation text. This implementation processes Doxygen's linebreak
+ * elements for controlling line spacing and text flow within content blocks.
+ *
+ * @public
+ */
 export class LineBreakDataModel extends AbstractDocEmptyType {
+    /**
+     * Constructs a LineBreakDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the line break data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocEmptyType whilst
+     * identifying the element as 'linebreak' for proper line break handling.
+     */
     constructor(xml, element) {
         super(xml, element, 'linebreak');
     }
 }
+/**
+ * Data model for horizontal ruler elements within documentation content.
+ *
+ * @remarks
+ * Represents horizontal ruler elements that provide visual separation
+ * between content sections. This implementation processes Doxygen's
+ * hruler elements for creating horizontal dividing lines within documentation.
+ *
+ * @public
+ */
 export class HrulerDataModel extends AbstractDocEmptyType {
+    /**
+     * Constructs an HrulerDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the horizontal ruler
+     *   data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocEmptyType whilst
+     * identifying the element as 'hruler' for proper horizontal line formatting.
+     */
     constructor(xml, element) {
         super(xml, element, 'hruler');
     }
 }
+/**
+ * Data model for non-breakable space elements within documentation content.
+ *
+ * @remarks
+ * Represents non-breakable space elements that provide control over text
+ * wrapping and spacing within documentation. This implementation processes
+ * Doxygen's nonbreakablespace elements for maintaining text cohesion
+ * across line breaks.
+ *
+ * @public
+ */
 export class NonBreakableSpaceDataModel extends AbstractDocEmptyType {
+    /**
+     * Constructs a NonBreakableSpaceDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the non-breakable
+     *   space data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocEmptyType whilst
+     * identifying the element as 'nonbreakablespace' for proper space handling.
+     */
     constructor(xml, element) {
         super(xml, element, 'nonbreakablespace');
     }
 }
 // Not yet used, present just to remind its presence.
 // <xsd:element name="para" type="docEmptyType" />
+/**
+ * Data model for empty paragraph elements within documentation content.
+ *
+ * @remarks
+ * Represents empty paragraph elements used as placeholders or structural
+ * markers within documentation. This implementation processes Doxygen's
+ * empty para elements, which serve as document structure indicators
+ * without containing content.
+ *
+ * @public
+ */
 export class ParaEmptyDataModel extends AbstractDocEmptyType {
+    /**
+     * Constructs a ParaEmptyDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the empty paragraph data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractDocEmptyType whilst
+     * identifying the element as 'para' for empty paragraph structure handling.
+     */
     constructor(xml, element) {
         super(xml, element, 'para');
     }
 }
 // ----------------------------------------------------------------------------
+/**
+ * Abstract base class for verbatim text elements within documentation content.
+ *
+ * @remarks
+ * Implements processing for verbatim content elements that preserve exact
+ * formatting and whitespace within documentation. This class handles
+ * elements that contain literal text content, such as code blocks and
+ * preformatted text, whilst maintaining their original formatting and
+ * character sequences.
+ *
+ * The implementation processes both textual content and structured markup
+ * elements that may appear within verbatim contexts, ensuring proper
+ * preservation of the intended display format.
+ *
+ * @public
+ */
 export class AbstractVerbatimType extends AbstractDataModelBase {
+    /**
+     * Constructs an AbstractVerbatimType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the verbatim data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes verbatim elements by extracting both textual
+     * content and any embedded markup elements. The parser maintains proper
+     * content order whilst preserving the original formatting and whitespace
+     * characteristics of the verbatim content.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -5955,13 +8511,64 @@ export class AbstractVerbatimType extends AbstractDataModelBase {
 }
 // WARNING: not text only, ref encountered in Doxygen reference site.
 // <xsd:element name="verbatim" type="xsd:string" />
+/**
+ * Data model for verbatim text elements within documentation content.
+ *
+ * @remarks
+ * Represents verbatim text elements that preserve exact formatting and
+ * whitespace for code blocks, examples, and literal text within documentation.
+ * This implementation processes Doxygen's verbatim elements, which maintain
+ * precise character sequences and formatting whilst potentially containing
+ * cross-references and other markup elements.
+ *
+ * @public
+ */
 export class VerbatimDataModel extends AbstractVerbatimType {
+    /**
+     * Constructs a VerbatimDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the verbatim data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractVerbatimType to handle
+     * verbatim content processing whilst identifying the element as 'verbatim'
+     * for proper literal text preservation and formatting.
+     */
     constructor(xml, element) {
         super(xml, element, 'verbatim');
     }
 }
 // ----------------------------------------------------------------------------
+/**
+ * Abstract base class for preformatted content elements within documentation.
+ *
+ * @remarks
+ * Implements processing for preformatted content elements that maintain
+ * specific formatting while supporting embedded markup elements. This class
+ * handles elements that preserve whitespace and formatting whilst allowing
+ * for structured content including cross-references and formatting markup.
+ *
+ * The implementation processes both textual content and document command
+ * group elements that may appear within preformatted contexts, ensuring
+ * proper content organisation and formatting preservation.
+ *
+ * @public
+ */
 export class AbstractPreformattedType extends AbstractDataModelBase {
+    /**
+     * Constructs an AbstractPreformattedType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the preformatted data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes preformatted elements by extracting both
+     * textual content and structured command group elements. The parser
+     * maintains proper content order whilst preserving formatting characteristics
+     * and enabling embedded markup within preformatted contexts.
+     */
     constructor(xml, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -5986,7 +8593,30 @@ export class AbstractPreformattedType extends AbstractDataModelBase {
     }
 }
 // <xsd:element name="preformatted" type="docMarkupType" />
+/**
+ * Data model for preformatted content elements within documentation.
+ *
+ * @remarks
+ * Represents preformatted content elements that preserve formatting while
+ * supporting embedded markup elements. This implementation processes
+ * Doxygen's preformatted elements, which maintain whitespace and formatting
+ * whilst allowing for structured content including cross-references and
+ * other documentation markup.
+ *
+ * @public
+ */
 export class PreformattedDataModel extends AbstractPreformattedType {
+    /**
+     * Constructs a PreformattedDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the preformatted data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractPreformattedType to
+     * handle preformatted content processing whilst identifying the element
+     * as 'preformatted' for proper formatting preservation and markup support.
+     */
     constructor(xml, element) {
         super(xml, element, 'preformatted');
     }