@xpack/doxygen2docusaurus 1.1.0 → 2.0.0

package/dist/doxygen2docusaurus.d.ts

@@ -14,530 +14,3265 @@
 import { XMLParser } from 'fast-xml-parser';
 
 /**
+ * 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 declare abstract class AbstractCodeLineType extends AbstractDataModelBase {
+    /**
+     * 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?: HighlightDataModel[] | undefined;
+    /**
+     * 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?: number | undefined;
+    /**
+     * 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?: string | undefined;
+    /**
+     * 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?: string | undefined;
+    /**
+     * 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?: boolean | undefined;
+    /**
+     * 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: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for Doxygen compound definition data models.
+ *
+ * @remarks
+ * Represents the core structure of compound definitions in Doxygen XML output,
+ * including classes, structures, files, namespaces, and other compound types.
+ * This class handles the complete XML schema for compound definitions with
+ * comprehensive element and attribute processing to capture all aspects of
+ * the documented code structures.
+ *
  * @public
  */
 export declare abstract class AbstractCompoundDefType extends AbstractDataModelBase {
+    /**
+     * The name of the compound element.
+     *
+     * @remarks
+     * Contains the fully qualified name of the compound (class, namespace,
+     * file, etc.) as extracted from the 'compoundname' XML element. This
+     * represents the primary identifier for the compound in the documentation
+     * hierarchy and is mandatory for all compound types except namespaces.
+     */
     compoundName: string;
+    /**
+     * Optional title for the compound.
+     *
+     * @remarks
+     * Provides a human-readable title for the compound that may differ from
+     * the compound name. This is typically used for pages and groups where
+     * a descriptive title is more appropriate than the technical identifier.
+     */
     title?: string | undefined;
+    /**
+     * Brief description of the compound.
+     *
+     * @remarks
+     * Contains a concise summary description of the compound extracted from
+     * the 'briefdescription' XML element. This provides a short overview
+     * suitable for listings and summary views of the documented entity.
+     */
     briefDescription?: BriefDescriptionDataModel | undefined;
+    /**
+     * Detailed description of the compound.
+     *
+     * @remarks
+     * Contains comprehensive documentation for the compound extracted from
+     * the 'detaileddescription' XML element. This includes full description
+     * text with formatting, examples, and other detailed documentation
+     * content.
+     */
     detailedDescription?: DetailedDescriptionDataModel | undefined;
+    /**
+     * Base compound references for inheritance relationships.
+     *
+     * @remarks
+     * Contains references to base classes or parent compounds from which
+     * this compound inherits. This property captures the inheritance
+     * hierarchy information extracted from 'basecompoundref' XML elements
+     * for object-oriented documentation structures.
+     */
     baseCompoundRefs?: BaseCompoundRefDataModel[] | undefined;
+    /**
+     * Derived compound references for inheritance relationships.
+     *
+     * @remarks
+     * Contains references to derived classes or child compounds that inherit
+     * from this compound. This property captures the inheritance hierarchy
+     * information extracted from 'derivedcompoundref' XML elements for
+     * complete inheritance documentation.
+     */
     derivedCompoundRefs?: DerivedCompoundRefDataModel[] | undefined;
+    /**
+     * Include file references for this compound.
+     *
+     * @remarks
+     * Contains information about header files or modules that this compound
+     * includes or depends upon. This property captures dependency
+     * relationships extracted from 'includes' XML elements, providing
+     * visibility into the file inclusion structure.
+     */
     includes?: IncludesDataModel[] | undefined;
+    /**
+     * Reverse include file references for this compound.
+     *
+     * @remarks
+     * Contains information about other files or compounds that include this
+     * compound. This property captures reverse dependency relationships
+     * extracted from 'includedby' XML elements, showing which entities
+     * depend on this compound.
+     */
     includedBy?: IncludedByDataModel[] | undefined;
+    /**
+     * Template parameter list for templated compounds.
+     *
+     * @remarks
+     * Contains the template parameter definitions for templated classes,
+     * functions, or other templated entities. This property captures
+     * template information extracted from 'templateparamlist' XML elements,
+     * providing details about generic programming constructs.
+     */
     templateParamList?: TemplateParamListDataModel | undefined;
+    /**
+     * Section definitions within the compound.
+     *
+     * @remarks
+     * Contains organised sections of members and documentation within the
+     * compound. This property captures structured content extracted from
+     * 'sectiondef' XML elements, providing hierarchical organisation of
+     * compound members by type and visibility.
+     */
     sectionDefs?: SectionDefDataModel[] | undefined;
+    /**
+     * Table of contents for the compound documentation.
+     *
+     * @remarks
+     * Contains the navigation structure for complex compound documentation.
+     * This property captures hierarchical content organisation extracted
+     * from 'tableofcontents' XML elements, providing structured navigation
+     * for large documentation entities.
+     */
     tableOfContents?: TableOfContentsDataModel | undefined;
+    /**
+     * Inner folder references contained within this compound.
+     *
+     * @remarks
+     * Contains references to subdirectories or folders that are logically
+     * contained within this compound. This property captures hierarchical
+     * folder structure extracted from 'innerdir' XML elements, typically
+     * used for directory-based documentation organisation.
+     */
     innerDirs?: InnerDirDataModel[] | undefined;
+    /**
+     * Inner file references contained within this compound.
+     *
+     * @remarks
+     * Contains references to files that are logically contained within this
+     * compound. This property captures file relationships extracted from
+     * 'innerfile' XML elements, providing visibility into compound-to-file
+     * associations in the documentation structure.
+     */
     innerFiles?: InnerFileDataModel[] | undefined;
+    /**
+     * Inner class references contained within this compound.
+     *
+     * @remarks
+     * Contains references to classes, structures, or other class-like
+     * entities that are defined within this compound. This property captures
+     * nested type relationships extracted from 'innerclass' XML elements,
+     * supporting hierarchical type documentation.
+     */
     innerClasses?: InnerClassDataModel[] | undefined;
+    /**
+     * Inner namespace references contained within this compound.
+     *
+     * @remarks
+     * Contains references to namespaces that are nested within this compound.
+     * This property captures namespace hierarchy relationships extracted from
+     * 'innernamespace' XML elements, supporting multi-level namespace
+     * documentation organisation.
+     */
     innerNamespaces?: InnerNamespaceDataModel[] | undefined;
+    /**
+     * Inner page references contained within this compound.
+     *
+     * @remarks
+     * Contains references to documentation pages that are logically
+     * associated with this compound. This property captures page
+     * relationships extracted from 'innerpage' XML elements, supporting
+     * structured documentation navigation.
+     */
     innerPages?: InnerPageDataModel[] | undefined;
+    /**
+     * Inner group references contained within this compound.
+     *
+     * @remarks
+     * Contains references to documentation groups that are associated with
+     * this compound. This property captures group relationships extracted
+     * from 'innergroup' XML elements, supporting thematic organisation of
+     * related documentation elements.
+     */
     innerGroups?: InnerGroupDataModel[] | undefined;
+    /**
+     * Program listing or source code for the compound.
+     *
+     * @remarks
+     * Contains the actual source code implementation or listing for the
+     * compound when available. This property captures code content extracted
+     * from 'programlisting' XML elements, providing syntax-highlighted
+     * source code display in the documentation.
+     */
     programListing?: ProgramListingDataModel | undefined;
+    /**
+     * Location information for the compound definition.
+     *
+     * @remarks
+     * Contains file path, line number, and other location details for where
+     * the compound is defined in the source code. This property captures
+     * location metadata extracted from 'location' XML elements, enabling
+     * source code navigation and reference linking.
+     */
     location?: LocationDataModel | undefined;
+    /**
+     * Complete list of all members contained in the compound.
+     *
+     * @remarks
+     * Contains a comprehensive list of all members (methods, properties,
+     * etc.) that belong to this compound, including inherited members.
+     * This property captures member information extracted from
+     * 'listofallmembers' XML elements for complete API documentation.
+     */
     listOfAllMembers?: ListOfAllMembersDataModel | undefined;
+    /**
+     * Unique identifier for the compound.
+     *
+     * @remarks
+     * Contains the unique ID assigned to this compound by Doxygen for
+     * cross-referencing and linking purposes. This identifier is mandatory
+     * and serves as the primary key for compound identification throughout
+     * the documentation system.
+     */
     id: string;
+    /**
+     * The kind or type of compound.
+     *
+     * @remarks
+     * Specifies the compound type using DoxCompoundKind enumeration values
+     * such as 'class', 'struct', 'file', 'namespace', 'page', etc. This
+     * mandatory attribute determines how the compound should be processed
+     * and displayed in the documentation output.
+     */
     kind: string;
+    /**
+     * Programming language of the compound.
+     *
+     * @remarks
+     * Specifies the programming language using DoxLanguage enumeration
+     * values when the compound is language-specific. This optional attribute
+     * enables language-aware processing and appropriate syntax highlighting
+     * in the generated documentation.
+     */
     language?: string | undefined;
+    /**
+     * Protection level of the compound.
+     *
+     * @remarks
+     * Specifies the access protection level (public, private, protected)
+     * for the compound using DoxProtectionKind enumeration values. Note
+     * that whilst this attribute is not marked as optional in the XML
+     * schema, it may not be present in all compound definitions.
+     */
     prot?: string | undefined;
+    /**
+     * Indicates whether the compound is marked as final.
+     *
+     * @remarks
+     * Specifies that the compound cannot be inherited from or extended,
+     * typically used in object-oriented programming languages that support
+     * final classes or sealed types. This boolean attribute reflects the
+     * final modifier in the source code.
+     */
     final?: boolean | undefined;
+    /**
+     * Indicates whether the compound is inline.
+     *
+     * @remarks
+     * Specifies that the compound is defined inline, typically used for
+     * functions, methods, or other constructs that are implemented directly
+     * in header files. This boolean attribute reflects inline declarations
+     * in the source code.
+     */
     inline?: boolean | undefined;
+    /**
+     * Indicates whether the compound is sealed.
+     *
+     * @remarks
+     * Specifies that the compound is sealed and cannot be inherited from,
+     * similar to final but using different language-specific terminology.
+     * This boolean attribute reflects sealed modifiers found in languages
+     * like C# or other object-oriented programming environments.
+     */
     sealed?: boolean | undefined;
+    /**
+     * Indicates whether the compound is abstract.
+     *
+     * @remarks
+     * Specifies that the compound is abstract and cannot be instantiated
+     * directly, typically requiring concrete implementations of abstract
+     * methods or properties. This boolean attribute reflects abstract
+     * modifiers in object-oriented programming languages.
+     */
     abstract?: boolean | undefined;
+    /**
+     * Constructs a new compound definition data model instance.
+     *
+     * @remarks
+     * Parses the complete XML structure for compound definitions, processing
+     * all elements and attributes according to the Doxygen XML schema. This
+     * includes handling optional and mandatory elements, complex nested
+     * structures, and comprehensive attribute validation to ensure data
+     * integrity throughout the parsing process.
+     *
+     * @param xml - The XML parser instance for processing elements
+     * @param element - The XML element object to parse
+     * @param elementName - The name of the XML element being processed
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for compound reference data models.
+ *
+ * @remarks
+ * Represents references to other compound entities in Doxygen XML output,
+ * including inheritance relationships and cross-references. This class
+ * handles the 'compoundRefType' XML schema structure with text content
+ * and attributes for protection level, virtual specification, and optional
+ * reference identifiers.
+ *
  * @public
  */
 export declare abstract class AbstractCompoundRefType extends AbstractDataModelBase {
+    /**
+     * The name or identifier text of the referenced compound.
+     *
+     * @remarks
+     * Contains the textual content extracted from the compound reference XML
+     * element, typically representing the name of the referenced class,
+     * structure, or other compound entity. This text content serves as the
+     * primary identifier for the referenced compound in inheritance
+     * relationships and cross-references.
+     */
     text: string;
+    /**
+     * Protection level of the compound reference.
+     *
+     * @remarks
+     * Specifies the access protection level using DoxProtectionKind
+     * enumeration values ('public', 'protected', 'private', 'package').
+     * This mandatory attribute determines the visibility and accessibility
+     * of the referenced compound in inheritance relationships.
+     */
     prot: string;
+    /**
+     * Virtual specification of the compound reference.
+     *
+     * @remarks
+     * Specifies the virtual nature using DoxVirtualKind enumeration values
+     * ('non-virtual', 'virtual', 'pure-virtual'). This mandatory attribute
+     * indicates whether the compound reference involves virtual inheritance
+     * or virtual methods in object-oriented programming contexts.
+     */
     virt: string;
+    /**
+     * Optional reference identifier for cross-linking.
+     *
+     * @remarks
+     * Contains the unique identifier that can be used to create hyperlinks
+     * or cross-references to the referenced compound's documentation. When
+     * present, this identifier enables navigation between related compound
+     * definitions in the generated documentation.
+     */
     refid?: string | undefined;
+    /**
+     * Constructs a new compound reference data model instance.
+     *
+     * @remarks
+     * Parses compound reference elements from Doxygen XML output, extracting
+     * the text content representing the compound name and processing attributes
+     * for protection level, virtual specification, and optional reference
+     * identifier. This provides the foundation for inheritance and
+     * cross-reference relationships in the documentation structure.
+     *
+     * @param xml - The XML parser instance for processing elements
+     * @param element - The XML element object to parse
+     * @param elementName - The name of the XML element being processed
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for all data model elements in the Doxygen XML layer.
+ *
+ * @remarks
+ * Provides the common interface and properties for all data model elements
+ * parsed from Doxygen XML files. All concrete data model classes should
+ * extend this base class to ensure consistent structure and behaviour.
+ *
  * @public
  */
 export declare abstract class AbstractDataModelBase {
+    /**
+     * The name of the XML element represented by this data model instance.
+     *
+     * @remarks
+     * Used to identify the XML element type for this data model object.
+     */
     elementName: string;
+    /**
+     * Indicates whether paragraph processing should be skipped for this element.
+     *
+     * @remarks
+     * Optional property used to control paragraph handling during documentation
+     * generation. If true, paragraph tags are not generated for this element.
+     */
     skipPara?: boolean;
+    /**
+     * The child elements or text nodes contained within this data model element.
+     *
+     * @remarks
+     * Contains an array of child elements or text nodes, supporting recursive
+     * data model structures for complex XML hierarchies.
+     */
     children?: (string | AbstractDataModelBase)[];
+    /**
+     * Constructs a new data model base instance for a given XML element name.
+     *
+     * @param elementName - The name of the XML element represented by this
+     *   instance
+     *
+     * @remarks
+     * Initialises the base data model with the specified element name. All
+     * derived data model classes should call this constructor.
+     */
     constructor(elementName: string);
 }
 
 /**
+ * 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 declare abstract class AbstractDescriptionType extends AbstractDataModelBase {
+    /**
+     * 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?: string | undefined;
+    /**
+     * 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: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * 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 declare abstract class AbstractDocImageType extends AbstractDataModelBase {
+    /**
+     * 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?: string | undefined;
+    /**
+     * 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?: string | undefined;
+    /**
+     * 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?: string | undefined;
+    /**
+     * 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?: string | undefined;
+    /**
+     * 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?: string | undefined;
+    /**
+     * 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?: boolean | undefined;
+    /**
+     * 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?: string | undefined;
+    /**
+     * 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: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for Doxygen file option type data models.
+ *
+ * @remarks
+ * Represents configuration option elements within Doxyfile XML structures,
+ * corresponding to the OptionType complex type in the XML schema. This
+ * class handles the parsing of option values and mandatory attributes
+ * (id, default, and type). All concrete option data model classes should
+ * extend this abstract base to ensure consistent parsing and data
+ * representation of Doxygen configuration settings.
+ *
  * @public
  */
 export declare abstract class AbstractDoxygenFileOptionType extends AbstractDataModelBase {
+    /**
+     * Collection of value strings associated with this configuration option.
+     *
+     * @remarks
+     * Optional array containing value elements found within the option
+     * structure. Each value represents a specific setting or parameter
+     * for the configuration option. The array supports zero to many values
+     * as per the XML schema, allowing for both single and multi-value
+     * configuration settings.
+     */
     values: string[] | undefined;
+    /**
+     * The unique identifier for this configuration option.
+     *
+     * @remarks
+     * Mandatory attribute that specifies the name or identifier of the
+     * Doxygen configuration option. This corresponds to the actual
+     * configuration parameter name used in Doxygen configuration files
+     * and determines the specific setting being configured.
+     */
     id: string;
-    default: string;
+    /**
+     * The default value indicator for this configuration option.
+     *
+     * @remarks
+     * Mandatory attribute that indicates whether this option is set to
+     * its default value. Corresponds to the defaultType enumeration in
+     * the XML schema, typically having values of 'yes' or 'no'.
+     */
+    default: string;
+    /**
+     * The data type classification for this configuration option.
+     *
+     * @remarks
+     * Mandatory attribute that specifies the expected data type for the
+     * option's values. Corresponds to the typeType enumeration in the
+     * XML schema, indicating whether the option expects integer, boolean,
+     * string, or string list values.
+     */
     type: string;
+    /**
+     * Constructs a new AbstractDoxygenFileOptionType instance from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML elements
+     * @param element - The XML element containing the option data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * Parses the provided XML element to extract configuration option
+     * information including value collections and mandatory attributes
+     * (id, default, and type). The constructor validates that all required
+     * attributes are present and processes value elements into a string
+     * array when present. The parsing ensures compliance with the OptionType
+     * schema definition.
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for Doxygen file type data models.
+ *
+ * @remarks
+ * Represents the structure of Doxyfile XML configurations, corresponding
+ * to the DoxygenFileType complex type in the XML schema. This class handles
+ * the parsing of Doxygen configuration options and mandatory attributes
+ * (version and language). All concrete Doxyfile data model classes should
+ * extend this abstract base to ensure consistent parsing and data
+ * representation of configuration settings.
+ *
  * @public
  */
 export declare abstract class AbstractDoxygenFileType extends AbstractDataModelBase {
+    /**
+     * The version of the Doxygen tool that generated the configuration.
+     *
+     * @remarks
+     * Mandatory attribute extracted from the XML structure that identifies
+     * the version of Doxygen used to generate the configuration file. This
+     * information is essential for compatibility and configuration parsing
+     * decisions.
+     */
     version: string;
+    /**
+     * The language specification for the documentation configuration.
+     *
+     * @remarks
+     * Mandatory attribute corresponding to the xml:lang attribute in the
+     * XML structure. Specifies the primary language used in the configuration
+     * and documentation generation process for internationalisation purposes.
+     */
     lang: string;
+    /**
+     * Collection of configuration option data models.
+     *
+     * @remarks
+     * Optional array containing option elements found within the Doxyfile
+     * structure. Each option represents a specific configuration setting
+     * that controls the behaviour of Doxygen during documentation generation.
+     * The array supports zero to many options as per the XML schema.
+     */
     options?: DoxygenFileOptionDataModel[] | undefined;
+    /**
+     * The XML schema location reference for validation.
+     *
+     * @remarks
+     * Optional attribute that specifies the location of the XML schema
+     * definition used for validating the structure of the Doxyfile XML.
+     * This provides schema validation capabilities for the parsed
+     * configuration content.
+     */
     noNamespaceSchemaLocation?: string | undefined;
+    /**
+     * Constructs a new AbstractDoxygenFileType instance from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML elements
+     * @param element - The XML element containing the Doxyfile data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * Parses the provided XML element to extract Doxyfile configuration
+     * information including option collections and mandatory attributes
+     * (version and language). The constructor validates that all required
+     * attributes are present and processes option elements into the
+     * appropriate data models. Optional schema location attributes are
+     * also extracted when present.
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for enumeration value data models.
+ *
+ * @remarks
+ * Represents individual values within enumeration types as parsed from
+ * Doxygen XML. Contains the value name, optional initialiser expression,
+ * and documentation descriptions with protection level information.
+ *
  * @public
  */
 export declare abstract class AbstractEnumValueType extends AbstractDataModelBase {
+    /**
+     * The name of the enumeration value.
+     *
+     * @remarks
+     * Simple identifier for the enumeration constant as it appears
+     * in the source code.
+     */
     name: string;
+    /**
+     * Optional initialiser expression for the enumeration value.
+     *
+     * @remarks
+     * Contains the explicit value assignment expression when the
+     * enumeration value is explicitly initialised in the source code.
+     */
     initializer?: InitializerDataModel | undefined;
+    /**
+     * Brief description of the enumeration value.
+     *
+     * @remarks
+     * Short documentation comment providing a concise explanation
+     * of the enumeration value's purpose or meaning.
+     */
     briefDescription?: BriefDescriptionDataModel | undefined;
+    /**
+     * Detailed description of the enumeration value.
+     *
+     * @remarks
+     * Comprehensive documentation comment providing full details
+     * about the enumeration value's purpose, usage, and behaviour.
+     */
     detailedDescription?: DetailedDescriptionDataModel | undefined;
+    /**
+     * Unique identifier for the enumeration value.
+     *
+     * @remarks
+     * Doxygen-generated identifier used for cross-referencing
+     * and creating links to this enumeration value.
+     */
     id: string;
+    /**
+     * Protection level of the enumeration value.
+     *
+     * @remarks
+     * Indicates the visibility scope such as 'public', 'private',
+     * or 'protected' based on Doxygen's protection kind enumeration.
+     */
     prot: string;
+    /**
+     * Creates a new enumeration value data model.
+     *
+     * @remarks
+     * Parses the XML element representing an enumeration value and
+     * extracts all relevant information including name, initialiser,
+     * descriptions, and attributes.
+     *
+     * @param xml - The XML parser instance
+     * @param element - The XML element to parse
+     * @param elementName - The name of the XML element
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * 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 declare abstract class AbstractHighlightType extends AbstractDataModelBase {
+    /**
+     * 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: string;
+    /**
+     * 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: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for include-type elements within documentation.
+ *
+ * @remarks
+ * Implements processing for include-type elements that represent file inclusion
+ * relationships within source code documentation. This class handles the XML
+ * Schema definition for incType elements, which contain textual content
+ * representing file paths or names along with attributes that specify inclusion
+ * behaviour and reference relationships.
+ *
+ * The implementation processes both local and system includes, distinguishing
+ * between quoted includes ("filename") and angle-bracket includes (<filename>)
+ * through the local attribute. Optional reference identifiers enable
+ * cross-referencing to the included file's documentation.
+ *
  * @public
  */
 export declare abstract class AbstractIncType extends AbstractDataModelBase {
+    /**
+     * The textual content representing the file path or name being included.
+     *
+     * @remarks
+     * Contains the file path or filename as specified in the include directive.
+     * This text content represents the actual filename that appears within
+     * the include statement in the source code, providing the reference to
+     * the included file within the documentation structure.
+     */
     text: string;
+    /**
+     * Indicates whether the include uses local or system include syntax.
+     *
+     * @remarks
+     * Determines the include syntax style: when true, indicates a local include
+     * using quotation marks ("filename"), when false, indicates a system include
+     * using angle brackets (<filename>). This distinction affects how the
+     * preprocessor searches for the included file.
+     */
     local: boolean;
+    /**
+     * Optional reference identifier for cross-linking to the included file.
+     *
+     * @remarks
+     * Contains the reference identifier that links to the documentation of
+     * the included file. This enables navigation from include statements to
+     * the actual file documentation within the generated documentation system.
+     */
     refId?: string | undefined;
+    /**
+     * Constructs an AbstractIncType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the include data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes include-type elements by extracting the
+     * textual content representing the filename and processing attributes
+     * that specify inclusion behaviour. The parser validates the presence
+     * of required content and attributes whilst maintaining compliance with
+     * the XML Schema definition for include elements.
+     *
+     * The implementation distinguishes between local and system includes
+     * through the local attribute and optionally associates reference
+     * identifiers for cross-linking to included file documentation.
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for index compound type data models.
+ *
+ * @remarks
+ * Represents compound elements found within Doxygen index XML structures,
+ * corresponding to the CompoundType complex type in the XML schema. This
+ * class handles the parsing of compound names, member collections, and
+ * mandatory attributes (refid and kind). All concrete compound data model
+ * classes should extend this abstract base to ensure consistent parsing
+ * and data representation.
+ *
  * @public
  */
 export declare abstract class AbstractIndexCompoundType extends AbstractDataModelBase {
+    /**
+     * The name of the compound element.
+     *
+     * @remarks
+     * Extracted from the mandatory 'name' element within the compound XML
+     * structure. Represents the identifier or name of the documented compound
+     * such as a class name, namespace, or filename.
+     */
     name: string;
+    /**
+     * Collection of member data models associated with this compound.
+     *
+     * @remarks
+     * Optional array containing member elements found within the compound
+     * structure. Each member represents a documented entity that belongs
+     * to this compound, such as functions, variables, or other nested
+     * constructs. The array supports zero to many members as per the XML schema.
+     */
     members: IndexMemberDataModel[] | undefined;
+    /**
+     * The unique reference identifier for this compound.
+     *
+     * @remarks
+     * Mandatory attribute that provides a unique identifier for referencing
+     * this compound within the Doxygen documentation structure. Used to link
+     * index entries to their detailed definitions in separate XML files.
+     */
     refid: string;
+    /**
+     * The kind classification of this compound.
+     *
+     * @remarks
+     * Mandatory attribute specifying the type of compound (e.g., class, struct,
+     * namespace, file). Corresponds to the CompoundKind enumeration in the
+     * XML schema, determining how the compound should be processed and presented.
+     */
     kind: string;
+    /**
+     * Constructs a new AbstractIndexCompoundType instance from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML elements
+     * @param element - The XML element containing the compound data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * Parses the provided XML element to extract compound information including
+     * the name element, member collections, and mandatory attributes (refid and
+     * kind). The constructor validates that all required data is present and
+     * properly formatted according to the XML schema specifications. Member
+     * elements are processed into IndexMemberDataModel instances when present.
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for Doxygen index type data models.
+ *
+ * @remarks
+ * Represents the top-level structure of Doxygen index XML files, corresponding
+ * to the DoxygenType complex type in the XML schema. This class handles the
+ * parsing of version and language attributes, along with compound element
+ * collections. Note that this definition may clash with similar types in
+ * compound.xsd, requiring careful namespace management.
+ *
  * @public
  */
 export declare abstract class AbstractIndexDoxygenType extends AbstractDataModelBase {
+    /**
+     * The version of the Doxygen tool that generated the XML.
+     *
+     * @remarks
+     * Mandatory attribute extracted from the XML structure that identifies
+     * the version of Doxygen used to generate the documentation. This
+     * information is crucial for compatibility and parsing decisions.
+     */
     version: string;
+    /**
+     * The language specification for the documentation content.
+     *
+     * @remarks
+     * Mandatory attribute corresponding to the xml:lang attribute in the
+     * XML structure. Specifies the primary language used in the documented
+     * content for internationalisation purposes.
+     */
     lang: string;
+    /**
+     * Collection of compound data models referenced in the index.
+     *
+     * @remarks
+     * Optional array containing compound elements found within the index
+     * structure. Each compound represents a documented entity such as
+     * classes, namespaces, or files that are catalogued in the index.
+     */
     compounds?: IndexCompoundDataModel[] | undefined;
+    /**
+     * The XML schema location reference for validation.
+     *
+     * @remarks
+     * Optional attribute that specifies the location of the XML schema
+     * definition used for validating the structure of the index XML file.
+     * This provides schema validation capabilities for the parsed content.
+     */
     noNamespaceSchemaLocation?: string | undefined;
+    /**
+     * Constructs a new AbstractIndexDoxygenType instance from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML elements
+     * @param element - The XML element containing the Doxygen index data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * Parses the provided XML element to extract Doxygen index information
+     * including compound collections and mandatory attributes (version and
+     * language). The constructor validates that all required attributes are
+     * present and processes compound elements into the appropriate data models.
+     * Optional schema location attributes are also extracted when present.
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for index member type data models.
+ *
+ * @remarks
+ * Represents member elements found within Doxygen index XML structures,
+ * corresponding to the MemberType complex type in the XML schema. This
+ * class handles the parsing of member names, reference identifiers, and
+ * member kinds from the XML structure. All concrete member data model
+ * classes should extend this abstract base to ensure consistent parsing
+ * and data representation.
+ *
  * @public
  */
 export declare abstract class AbstractIndexMemberType extends AbstractDataModelBase {
+    /**
+     * The name of the member element.
+     *
+     * @remarks
+     * Extracted from the mandatory 'name' element within the member XML
+     * structure. Represents the identifier or name of the documented member.
+     */
     name: string;
+    /**
+     * The reference identifier for the member.
+     *
+     * @remarks
+     * Mandatory attribute that provides a unique identifier for referencing
+     * this member within the Doxygen documentation structure. Used to link
+     * index entries to their detailed definitions.
+     */
     refid: string;
+    /**
+     * The kind classification of the member.
+     *
+     * @remarks
+     * Mandatory attribute specifying the type of member (e.g., function,
+     * variable, typedef). Corresponds to the MemberKind enumeration in the
+     * XML schema.
+     */
     kind: string;
+    /**
+     * Constructs a new AbstractIndexMemberType instance from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML elements
+     * @param element - The XML element containing the member data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * Parses the provided XML element to extract member information including
+     * the name element and mandatory attributes (refid and kind). The constructor
+     * validates that all required data is present and properly formatted
+     * according to the XML schema specifications.
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for linked text elements within documentation content.
+ *
+ * @remarks
+ * Implements processing for linked text elements that contain mixed content
+ * including both textual content and reference elements. This class handles
+ * the XML Schema definition for linkedTextType elements, which support
+ * character data interspersed with reference elements that provide
+ * cross-linking capabilities within documentation structures.
+ *
+ * The implementation processes sequences of text strings and RefTextDataModel
+ * instances, maintaining their original order to preserve the intended
+ * content flow whilst enabling interactive cross-references within the
+ * generated documentation.
+ *
  * @public
  */
 export declare abstract class AbstractLinkedTextType extends AbstractDataModelBase {
+    /**
+     * Constructs an AbstractLinkedTextType instance from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the linked text data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * This constructor processes linked text elements by extracting both
+     * textual content and reference elements in their original order. The
+     * parser maintains the mixed content structure whilst creating appropriate
+     * RefTextDataModel instances for cross-reference elements, ensuring
+     * proper content flow and interactive linking capabilities within the
+     * documentation system.
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * 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 declare abstract 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: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * 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 declare abstract class AbstractListingTypeBase extends AbstractDataModelBase {
+    /**
+     * 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?: CodeLineDataModel[] | undefined;
+    /**
+     * 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?: string | undefined;
 }
 
 /**
+ * Abstract base class for list-of-all-members elements within documentation.
+ *
+ * @remarks
+ * Implements processing for list-of-all-members elements that contain
+ * comprehensive member reference collections within class and compound
+ * documentation. This class handles the XML Schema definition for
+ * listofallmembersType elements, which provide complete inventories of
+ * all members (including inherited members) associated with classes,
+ * structures, and other compound types.
+ *
+ * The implementation processes sequences of member reference elements,
+ * creating MemberRefDataModel instances to maintain detailed information
+ * about each member's identity, scope, and accessibility within the
+ * compound's complete member hierarchy.
+ *
  * @public
  */
 export declare abstract class AbstractListOfAllMembersType extends AbstractDataModelBase {
+    /**
+     * Collection of member reference elements within the list-of-all-members.
+     *
+     * @remarks
+     * Contains processed member reference data models representing all members
+     * associated with the compound, including both directly declared and
+     * inherited members. Each reference provides comprehensive identification
+     * and scope information for the corresponding member element.
+     *
+     * @public
+     */
     memberRefs?: MemberRefDataModel[] | undefined;
+    /**
+     * Constructs a new list-of-all-members data model instance.
+     *
+     * @param xml - The XML parser instance for processing elements
+     * @param element - The source XML element containing list-of-all-members data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * Processes the XML element to extract and organise member reference
+     * information, creating appropriate data model instances for each
+     * member entry found within the comprehensive member listing.
+     * The constructor validates the element structure and ensures
+     * all member references are properly instantiated.
+     *
+     * @public
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for location information data models.
+ *
+ * @remarks
+ * Represents comprehensive source code location information as parsed from
+ * Doxygen XML elements, including file paths, line numbers, and column
+ * positions for both declarations and implementations. This class provides
+ * the foundation for tracking source location references within the
+ * documentation system, enabling precise navigation between documentation
+ * and source code.
+ *
+ * The implementation handles the XML Schema definition for locationType
+ * elements, which contain detailed positioning information for code elements
+ * including separate tracking of declaration and implementation locations
+ * when they differ (such as header/source file pairs).
+ *
  * @public
  */
 export declare abstract class AbstractLocationType extends AbstractDataModelBase {
+    /**
+     * The source file path containing the primary declaration or definition.
+     *
+     * @remarks
+     * File path as recorded by Doxygen, typically relative to the source tree
+     * root or absolute depending on configuration settings. This represents
+     * the primary file location where the documented element is defined.
+     *
+     * @public
+     */
     file: string;
+    /**
+     * The line number in the primary source file.
+     *
+     * @remarks
+     * Line number where the declaration or definition appears within the
+     * primary source file. Note that whilst the XSD specification indicates
+     * this as mandatory, in practice it may be undefined for certain elements
+     * where precise line information is not available or applicable.
+     *
+     * @public
+     */
     line?: number | undefined;
+    /**
+     * The column number in the primary source file.
+     *
+     * @remarks
+     * Column position where the declaration or definition begins, providing
+     * precise horizontal location information when available. This enables
+     * accurate source code navigation and positioning within development
+     * environments.
+     *
+     * @public
+     */
     column?: number | undefined;
+    /**
+     * The file path containing the declaration when separate from implementation.
+     *
+     * @remarks
+     * File path for the declaration when it differs from the implementation
+     * file, typically occurring in header/source file pairs where declarations
+     * are placed in header files whilst implementations reside in source files.
+     * This separation is common in C/C++ development patterns.
+     *
+     * @public
+     */
     declfile?: string | undefined;
+    /**
+     * The line number of the declaration within the declaration file.
+     *
+     * @remarks
+     * Line number where the declaration appears, separate from the
+     * implementation location when they differ. This provides precise
+     * positioning within the declaration file for accurate source navigation.
+     *
+     * @public
+     */
     declline?: number | undefined;
+    /**
+     * The column number of the declaration within the declaration file.
+     *
+     * @remarks
+     * Column position where the declaration begins, providing precise
+     * horizontal location information for the declaration. This enables
+     * accurate positioning within development environments when navigating
+     * to declaration locations.
+     *
+     * @public
+     */
     declcolumn?: number | undefined;
+    /**
+     * The file path containing the implementation body.
+     *
+     * @remarks
+     * File path where the function or method body is implemented, separate
+     * from the declaration when they differ. This is particularly relevant
+     * for languages that support separate declaration and implementation
+     * files, enabling precise navigation to implementation code.
+     *
+     * @public
+     */
     bodyfile?: string | undefined;
+    /**
+     * The starting line number of the implementation body.
+     *
+     * @remarks
+     * Line number where the implementation body begins, providing the starting
+     * boundary for locating function or method implementations. This is useful
+     * for identifying the complete scope of implementation code.
+     *
+     * @public
+     */
     bodystart?: number | undefined;
+    /**
+     * The ending line number of the implementation body.
+     *
+     * @remarks
+     * Line number where the implementation body ends, providing the complete
+     * range of the implementation. Together with bodystart, this defines the
+     * full extent of the implementation code within the source file.
+     *
+     * @public
+     */
     bodyend?: number | undefined;
+    /**
+     * Constructs a new location data model from XML element data.
+     *
+     * @param xml - The XML parser instance for processing element data
+     * @param element - The XML element containing location information
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * Parses the XML element representing location information and extracts
+     * file paths, line numbers, and column positions for declarations and
+     * implementations. The constructor processes all available location
+     * attributes whilst handling the distinction between declaration and
+     * implementation locations when they differ.
+     *
+     * The implementation ensures that mandatory file information is present
+     * and validates the element structure according to the XML Schema
+     * definition for locationType elements.
+     *
+     * @public
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for member-related data models within documentation.
+ *
+ * @remarks
+ * Provides foundational functionality for all member-related elements within
+ * the Doxygen documentation system. This class establishes the basic
+ * structure for member identification and classification, serving as the
+ * foundation for more specific member definition processing.
+ *
+ * The class maintains essential member information including name and kind
+ * identification, which are fundamental properties required by all member
+ * types within the documentation hierarchy.
+ *
  * @public
  */
 export declare abstract class AbstractMemberBaseType extends AbstractDataModelBase {
+    /**
+     * The name of the member element.
+     *
+     * @remarks
+     * Contains the identifier name for the member as extracted from the
+     * documentation source. This represents the primary identification
+     * mechanism for the member within its containing scope.
+     *
+     * @public
+     */
     name: string;
+    /**
+     * The kind classification of the member element.
+     *
+     * @remarks
+     * Specifies the type category of the member, corresponding to the
+     * DoxMemberKind enumeration values. This classification determines
+     * how the member is processed and presented within the documentation
+     * generation workflow.
+     *
+     * @public
+     */
     kind: string;
 }
 
 /**
+ * Abstract base class for comprehensive member definition data models.
+ *
+ * @remarks
+ * Extends the basic member functionality to provide complete member
+ * definition processing capabilities. This class handles the complex XML
+ * Schema definition for memberdefType elements, which represent detailed
+ * member information including location data, type information, parameters,
+ * descriptions, and various language-specific attributes.
+ *
+ * The implementation processes extensive member metadata including template
+ * parameters, function signatures, initialization values, documentation
+ * descriptions, and cross-reference information. It also manages a
+ * comprehensive set of language-specific attributes covering C++, Qt,
+ * C++/CLI, C#, Objective-C, and UNO IDL constructs.
+ *
  * @public
  */
 export declare abstract class AbstractMemberDefType extends AbstractMemberBaseType {
+    /**
+     * The location information for the member definition.
+     *
+     * @remarks
+     * Contains comprehensive source code location data including file paths,
+     * line numbers, and column positions for both declarations and
+     * implementations. This enables precise navigation between documentation
+     * and source code.
+     *
+     * @public
+     */
     location: LocationDataModel | undefined;
+    /**
+     * The unique identifier for the member element.
+     *
+     * @remarks
+     * Provides a unique identification string for the member within the
+     * documentation system. This identifier is used for cross-referencing
+     * and linking between different parts of the documentation.
+     *
+     * @public
+     */
     id: string;
+    /**
+     * The protection level of the member element.
+     *
+     * @remarks
+     * Specifies the access protection level (public, protected, private)
+     * for the member, determining its visibility and accessibility within
+     * the containing class or namespace scope.
+     *
+     * @public
+     */
     prot: string;
+    /**
+     * Indicates whether the member is declared as static.
+     *
+     * @remarks
+     * Boolean flag indicating static member declaration, affecting the
+     * member's association with class instances versus the class itself.
+     * This information is crucial for understanding member accessibility
+     * and usage patterns.
+     *
+     * @public
+     */
     staticc: boolean | undefined;
+    /**
+     * Template parameter list information for templated members.
+     *
+     * @remarks
+     * Contains detailed information about template parameters when the member
+     * is part of a template declaration. This includes parameter names, types,
+     * and default values essential for template documentation.
+     *
+     * @public
+     */
     templateparamlist?: TemplateParamListDataModel | undefined;
+    /**
+     * Type information for the member element.
+     *
+     * @remarks
+     * Provides comprehensive type data including linked text with embedded
+     * cross-references. This information describes the member's data type,
+     * return type for functions, or variable type for data members.
+     *
+     * @public
+     */
     type?: TypeDataModel | undefined;
+    /**
+     * The complete definition string for the member.
+     *
+     * @remarks
+     * Contains the full member definition as it appears in the source code,
+     * including type information, qualifiers, and parameter lists. This
+     * provides the complete syntactic representation of the member.
+     *
+     * @public
+     */
     definition?: string | undefined;
+    /**
+     * The argument string for function members.
+     *
+     * @remarks
+     * Contains the parameter list specification for function-like members,
+     * including parameter types, names, and default values. This information
+     * is essential for understanding function signatures and usage.
+     *
+     * @public
+     */
     argsstring?: string | undefined;
+    /**
+     * The fully qualified name of the member element.
+     *
+     * @remarks
+     * Provides the complete qualified name including namespace and class
+     * prefixes, enabling unambiguous identification of the member within
+     * the entire codebase context.
+     *
+     * @public
+     */
     qualifiedName?: string | undefined;
+    /**
+     * Bitfield specification for member variables.
+     *
+     * @remarks
+     * Contains the bitfield width specification for member variables that
+     * are declared as bitfields in C/C++ structures or classes. This string
+     * represents the number of bits allocated to the member within the
+     * containing structure's memory layout.
+     */
     bitfield?: string | undefined;
+    /**
+     * List of reimplemented member references.
+     *
+     * @remarks
+     * Contains references to members that this member reimplements or
+     * overrides from base classes. This property captures inheritance
+     * relationships where the current member provides a new implementation
+     * of a virtual method from a parent class.
+     */
     reimplements?: ReimplementDataModel[] | undefined;
+    /**
+     * List of members that reimplement this member.
+     *
+     * @remarks
+     * Contains references to derived class members that reimplement or
+     * override this member. This property provides reverse inheritance
+     * relationship information, showing which child classes provide
+     * alternative implementations of this member.
+     */
     reimplementedBys?: ReimplementDataModel[] | undefined;
+    /**
+     * Parameter list for function or method members.
+     *
+     * @remarks
+     * Contains detailed parameter information for function-like members,
+     * including parameter names, types, descriptions, and default values.
+     * This comprehensive parameter data enables complete function signature
+     * documentation and API reference generation.
+     */
     params?: ParamDataModel[] | undefined;
+    /**
+     * Enumeration values for enum members.
+     *
+     * @remarks
+     * Contains the list of enumeration constants when the member is an enum
+     * type. Each enumeration value includes its name, numeric value, and
+     * associated documentation, providing complete enum documentation
+     * for API references.
+     */
     enumvalues?: EnumValueDataModel[] | undefined;
+    /**
+     * Initializer expression for the member.
+     *
+     * @remarks
+     * Contains the initialization expression or default value assigned to
+     * the member in its declaration. This linked text may include
+     * cross-references to other documented entities and provides insight
+     * into the member's default behaviour or initial state.
+     */
     initializer?: InitializerDataModel | undefined;
+    /**
+     * Brief description of the member.
+     *
+     * @remarks
+     * Contains a concise summary description of the member extracted from
+     * documentation comments. This brief description is typically used in
+     * member listings and summary views to provide quick understanding
+     * of the member's purpose.
+     */
     briefDescription?: BriefDescriptionDataModel | undefined;
+    /**
+     * Detailed description of the member.
+     *
+     * @remarks
+     * Contains comprehensive documentation for the member including detailed
+     * explanations, usage examples, parameter descriptions, and return value
+     * information. This forms the primary documentation content for the
+     * member in generated API documentation.
+     */
     detailedDescription?: DetailedDescriptionDataModel | undefined;
+    /**
+     * In-body description of the member.
+     *
+     * @remarks
+     * Contains documentation that appears within the member's implementation
+     * body, typically used for additional implementation notes or internal
+     * documentation that supplements the main member description.
+     */
     inbodyDescription?: InbodyDescriptionDataModel | undefined;
+    /**
+     * References made by this member to other entities.
+     *
+     * @remarks
+     * Contains a list of references to other documented entities that this
+     * member uses or calls. This information enables dependency analysis
+     * and cross-reference navigation in the generated documentation.
+     */
     references?: ReferenceDataModel[] | undefined;
+    /**
+     * References to this member from other entities.
+     *
+     * @remarks
+     * Contains a list of other documented entities that reference or use
+     * this member. This reverse reference information helps understand
+     * the member's usage throughout the codebase and enables comprehensive
+     * cross-reference navigation.
+     */
     referencedBy?: ReferencedByDataModel[] | undefined;
+    /**
+     * Indicates whether the member has external linkage.
+     *
+     * @remarks
+     * Boolean flag indicating that the member is declared with external
+     * linkage, typically using the 'extern' keyword in C/C++. This affects
+     * the member's visibility and linkage across translation units.
+     */
     extern?: boolean | undefined;
+    /**
+     * Indicates whether the member has strong typing.
+     *
+     * @remarks
+     * Boolean flag indicating strong type enforcement for the member,
+     * typically used in languages or contexts where type strength can
+     * be explicitly specified to prevent implicit conversions.
+     */
     strong?: boolean | undefined;
+    /**
+     * Indicates whether the member is declared as const.
+     *
+     * @remarks
+     * Boolean flag indicating that the member is declared with the const
+     * qualifier, making it immutable after initialization. This affects
+     * the member's usage patterns and compiler optimizations.
+     */
     constt?: boolean | undefined;
+    /**
+     * Indicates whether the member is declared as explicit.
+     *
+     * @remarks
+     * Boolean flag indicating that constructors or conversion operators
+     * are marked as explicit, preventing implicit conversions. This is
+     * particularly important for type safety in C++ class design.
+     */
     explicit?: boolean | undefined;
+    /**
+     * Indicates whether the member is declared as inline.
+     *
+     * @remarks
+     * Boolean flag indicating that the member is defined inline, suggesting
+     * to the compiler that calls should be expanded in place rather than
+     * using function call mechanisms. This affects performance and linking.
+     */
     inline?: boolean | undefined;
+    /**
+     * Indicates the reference qualifier for the member.
+     *
+     * @remarks
+     * Boolean flag related to C++11 reference qualifiers (&, &&) that
+     * specify whether member functions can be called on lvalue or rvalue
+     * objects. This affects method overload resolution and move semantics.
+     */
     refqual?: boolean | undefined;
+    /**
+     * Virtual specification for the member.
+     *
+     * @remarks
+     * String indicating the virtual nature of the member using DoxVirtualKind
+     * values ('non-virtual', 'virtual', 'pure-virtual'). This determines
+     * the member's behaviour in inheritance hierarchies and polymorphism.
+     */
     virt?: string | undefined;
+    /**
+     * Indicates whether the member is declared as volatile.
+     *
+     * @remarks
+     * Boolean flag indicating that the member is declared with the volatile
+     * qualifier, preventing compiler optimizations that assume the value
+     * doesn't change unexpectedly. This is important for hardware registers
+     * and multi-threaded contexts.
+     */
     volatile?: boolean | undefined;
+    /**
+     * Indicates whether the member is declared as mutable.
+     *
+     * @remarks
+     * Boolean flag indicating that the member can be modified even in const
+     * objects. This is typically used for caching, lazy evaluation, or
+     * other implementation details that don't affect the logical state.
+     */
     mutable?: boolean | undefined;
+    /**
+     * Indicates whether the member is declared as noexcept.
+     *
+     * @remarks
+     * Boolean flag indicating that the member promises not to throw
+     * exceptions. This C++11 feature enables compiler optimizations and
+     * affects exception safety guarantees in the API design.
+     */
     noexcept?: boolean | undefined;
+    /**
+     * Indicates whether the member has a noexcept expression.
+     *
+     * @remarks
+     * Boolean flag indicating that the member's noexcept specification
+     * includes a conditional expression that determines exception safety
+     * at compile time based on template parameters or other conditions.
+     */
     noexceptexpression?: boolean | undefined;
+    /**
+     * Indicates whether the member is declared as nodiscard.
+     *
+     * @remarks
+     * Boolean flag indicating that the member's return value should not
+     * be ignored by callers. This C++17 attribute helps prevent common
+     * programming errors where important return values are discarded.
+     */
     nodiscard?: boolean | undefined;
+    /**
+     * Indicates whether the member is declared as constexpr.
+     *
+     * @remarks
+     * Boolean flag indicating that the member can be evaluated at compile
+     * time when given constant expressions as arguments. This C++11 feature
+     * enables compile-time computation and optimization.
+     */
     constexpr?: boolean | undefined;
+    /**
+     * Indicates whether the member is declared as consteval.
+     *
+     * @remarks
+     * Boolean flag indicating that the member must be evaluated at compile
+     * time. This C++20 feature is stronger than constexpr, requiring
+     * immediate evaluation during compilation.
+     */
     consteval?: boolean | undefined;
+    /**
+     * Indicates whether the member is declared as constinit.
+     *
+     * @remarks
+     * Boolean flag indicating that the member must be initialized with
+     * a constant expression during static initialization. This C++20
+     * feature helps prevent initialization order issues.
+     */
     constinit?: boolean | undefined;
+    /**
+     * Indicates whether the member is declared as final.
+     *
+     * @remarks
+     * Boolean flag indicating that virtual members cannot be overridden
+     * in derived classes. This provides explicit control over inheritance
+     * hierarchies and enables compiler optimizations.
+     */
     final?: boolean | undefined;
+    /**
+     * Constructs a new member definition data model from XML element data.
+     *
+     * @param xml - The XML parser instance for processing element data
+     * @param element - The XML element containing member definition information
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * Processes the comprehensive XML element representing member definition
+     * information and extracts all available metadata including location data,
+     * type information, parameters, descriptions, and language-specific
+     * attributes. The constructor handles the complex memberdefType schema
+     * with its extensive set of optional elements and attributes.
+     *
+     * The implementation validates mandatory elements (name, location, kind,
+     * id, protection) whilst gracefully handling optional elements and
+     * attributes. It processes various member types including functions,
+     * variables, typedefs, enums, and specialised constructs from multiple
+     * programming languages and frameworks.
+     *
+     * @public
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for member reference data models within documentation.
+ *
+ * @remarks
+ * Represents comprehensive references to class or namespace members as
+ * parsed from Doxygen XML elements. This class processes memberRefType
+ * schema definitions which contain scope information, member names, and
+ * essential attributes required for cross-referencing and link generation
+ * within the documentation system.
+ *
+ * The implementation handles the complete set of member reference metadata
+ * including qualified scope identification, protection levels, virtual
+ * inheritance characteristics, and ambiguity resolution information.
+ * This enables accurate cross-reference generation and navigation between
+ * different parts of the documentation.
+ *
  * @public
  */
 export declare abstract class AbstractMemberRefType extends AbstractDataModelBase {
+    /**
+     * The containing scope for the referenced member element.
+     *
+     * @remarks
+     * Specifies the namespace, class, or other containing context that
+     * houses the referenced member. This scope information provides the
+     * qualified context necessary for proper member identification and
+     * disambiguation within the documentation hierarchy.
+     *
+     * @public
+     */
     scope: string;
+    /**
+     * The identifier name of the referenced member element.
+     *
+     * @remarks
+     * Contains the simple identifier name for the member being referenced,
+     * which serves as the primary display name and is used for link
+     * generation within the documentation system. This name is used in
+     * conjunction with the scope to provide complete member identification.
+     *
+     * @public
+     */
     name: string;
+    /**
+     * The unique reference identifier for cross-referencing the member.
+     *
+     * @remarks
+     * Contains the Doxygen-generated unique identifier used for creating
+     * precise cross-references and hyperlinks to the member documentation.
+     * This identifier ensures unambiguous linking between documentation
+     * elements and enables accurate navigation within the generated
+     * documentation system.
+     *
+     * @public
+     */
     refid: string;
+    /**
+     * The protection level classification of the referenced member.
+     *
+     * @remarks
+     * Specifies the access protection level such as 'public', 'private',
+     * or 'protected' based on Doxygen's DoxProtectionKind enumeration.
+     * This information determines the member's visibility and accessibility
+     * within its containing scope and affects documentation presentation.
+     *
+     * @public
+     */
     prot: string;
+    /**
+     * The virtual inheritance classification of the referenced member.
+     *
+     * @remarks
+     * Indicates the virtual nature such as 'virtual', 'pure-virtual',
+     * or 'non-virtual' based on Doxygen's DoxVirtualKind enumeration.
+     * This classification is essential for understanding inheritance
+     * relationships and member override behaviour within class hierarchies.
+     *
+     * @public
+     */
     virt: string;
+    /**
+     * The ambiguity resolution scope for member reference disambiguation.
+     *
+     * @remarks
+     * Provides optional scope information used to resolve ambiguous member
+     * references when multiple members with identical names exist within
+     * the documentation context. This field assists in ensuring accurate
+     * member identification when name conflicts occur.
+     *
+     * Note that this deviates from the XML Schema definition where it is
+     * marked as required, but in practice may be undefined for certain
+     * member references.
+     *
+     * @public
+     */
     ambiguityscope?: string | undefined;
+    /**
+     * Constructs a new member reference data model from XML element data.
+     *
+     * @param xml - The XML parser instance for processing element data
+     * @param element - The XML element containing member reference information
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * Processes the XML element representing member reference information
+     * and extracts scope identification, member names, and reference
+     * attributes required for cross-referencing functionality. The
+     * constructor validates mandatory elements and attributes whilst
+     * gracefully handling optional ambiguity scope information.
+     *
+     * The implementation ensures that essential reference data (scope, name,
+     * refid, protection, virtual kind) is properly extracted and validated
+     * according to the memberRefType schema requirements.
+     *
+     * @public
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for member type data models within documentation.
+ *
+ * @remarks
+ * Represents member elements as defined by the MemberType XML Schema,
+ * providing fundamental member identification and classification
+ * functionality. This class extends AbstractMemberBaseType to handle
+ * the specific requirements of member elements that contain simplified
+ * member information with reference identifiers.
+ *
+ * The implementation processes member elements that primarily serve as
+ * lightweight references to more detailed member definitions, maintaining
+ * essential identification data including names, reference identifiers,
+ * and member kind classifications for cross-referencing purposes.
+ *
  * @public
  */
 export declare abstract class AbstractMemberType extends AbstractMemberBaseType {
+    /**
+     * The unique reference identifier for the member element.
+     *
+     * @remarks
+     * Contains the Doxygen-generated unique identifier used for creating
+     * cross-references and hyperlinks to the detailed member definition.
+     * This identifier serves as the primary mechanism for linking between
+     * member references and their corresponding comprehensive definitions
+     * within the documentation system.
+     *
+     * @public
+     */
     refid: string;
+    /**
+     * Constructs a new member type data model from XML element data.
+     *
+     * @param xml - The XML parser instance for processing element data
+     * @param element - The XML element containing member type information
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * Processes the XML element representing simplified member information
+     * and extracts the essential identification data including name and
+     * reference identifier. The constructor handles the MemberType schema
+     * requirements whilst accommodating the practical deviation where
+     * member names may be empty in certain contexts.
+     *
+     * The implementation validates mandatory attributes (refid, kind) and
+     * ensures proper element structure according to the XML Schema
+     * definition for MemberType elements.
+     *
+     * @public
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for parameter data models within documentation.
+ *
+ * @remarks
+ * Represents comprehensive parameter information as defined by the paramType
+ * XML Schema, handling function and method parameter definitions including
+ * type information, naming variations, default values, and constraints.
+ * This class processes the complete range of parameter metadata required
+ * for accurate function signature documentation.
+ *
+ * The implementation manages optional parameter elements including
+ * attributes, type specifications with linked text support, declaration
+ * and definition names, array specifications, default values, type
+ * constraints, and brief descriptions. All elements are optional,
+ * reflecting the flexible nature of parameter documentation within
+ * different programming contexts.
+ *
  * @public
  */
 export declare abstract class AbstractParamType extends AbstractDataModelBase {
+    /**
+     * Parameter attributes specification string.
+     *
+     * @remarks
+     * Contains language-specific parameter attributes such as qualifiers,
+     * modifiers, or annotations that apply to the parameter declaration.
+     * This information provides additional context about parameter
+     * behaviour and constraints within the function signature.
+     *
+     * @public
+     */
     attributes?: string | undefined;
+    /**
+     * Type information for the parameter with linked text support.
+     *
+     * @remarks
+     * Provides comprehensive type data including cross-references and
+     * embedded links to type definitions. This enables rich type
+     * presentation with navigation capabilities to related type
+     * documentation within the system.
+     *
+     * @public
+     */
     type?: TypeDataModel | undefined;
+    /**
+     * The declared parameter name as it appears in the declaration.
+     *
+     * @remarks
+     * Contains the parameter name as specified in the function or method
+     * declaration, representing the formal parameter identifier used
+     * within the function signature for identification purposes.
+     *
+     * @public
+     */
     declname?: string | undefined;
+    /**
+     * The defined parameter name as it appears in the definition.
+     *
+     * @remarks
+     * Contains the parameter name as used in the function or method
+     * definition, which may differ from the declaration name in contexts
+     * where declarations and definitions are separate (such as header
+     * and implementation files).
+     *
+     * @public
+     */
     defname?: string | undefined;
+    /**
+     * Array specification information for array parameters.
+     *
+     * @remarks
+     * Contains array dimension information and specifications when the
+     * parameter represents an array type. This includes array bounds,
+     * size specifications, and dimensional characteristics essential
+     * for accurate parameter documentation.
+     *
+     * @public
+     */
     array?: string | undefined;
+    /**
+     * Default value specification with linked text support.
+     *
+     * @remarks
+     * Provides the parameter's default value information including
+     * cross-references to related elements when the default value
+     * contains references to other documented entities. This enables
+     * comprehensive default value presentation with navigation
+     * capabilities.
+     *
+     * @public
+     */
     defval?: DefValDataModel | undefined;
+    /**
+     * Type constraint information for template parameters.
+     *
+     * @remarks
+     * Contains constraint specifications for template or generic
+     * parameters, including concept requirements, type bounds, and
+     * constraint expressions. This information is essential for
+     * documenting modern C++ concepts and generic programming
+     * constraints.
+     *
+     * @public
+     */
     typeconstraint?: TypeConstraintDataModel | undefined;
+    /**
+     * Brief description documentation for the parameter.
+     *
+     * @remarks
+     * Provides concise parameter documentation including purpose,
+     * usage notes, and essential parameter information. This
+     * description enhances parameter understanding within function
+     * documentation and API reference materials.
+     *
+     * @public
+     */
     briefdescription?: BriefDescriptionDataModel | undefined;
+    /**
+     * Constructs a new parameter data model from XML element data.
+     *
+     * @param xml - The XML parser instance for processing element data
+     * @param element - The XML element containing parameter information
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * Processes the XML element representing parameter information and
+     * extracts all available parameter metadata including attributes,
+     * type specifications, naming variations, default values, constraints,
+     * and descriptions. The constructor handles the paramType schema
+     * requirements where all elements are optional, reflecting the
+     * flexible nature of parameter documentation.
+     *
+     * The implementation processes various parameter representations
+     * including simple parameters, array parameters, template parameters
+     * with constraints, and parameters with default values. It ensures
+     * proper extraction of linked text elements that contain embedded
+     * cross-references to related documentation entities.
+     *
+     * @public
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for reference type data models.
+ *
+ * @remarks
+ * Represents the foundational structure for reference relationship elements
+ * within Doxygen XML documentation, corresponding to the referenceType
+ * complex type in the XML schema. This class manages bidirectional reference
+ * relationships between documented entities, capturing both the descriptive
+ * text and precise location information including line number ranges. The
+ * reference system enables comprehensive dependency tracking and cross-
+ * referencing capabilities, essential for understanding code relationships
+ * and generating accurate documentation navigation structures.
+ *
  * @public
  */
 export declare abstract class AbstractReferenceType extends AbstractDataModelBase {
+    /**
+     * The descriptive text content for this reference relationship.
+     *
+     * @remarks
+     * Contains the textual description of the reference relationship, typically
+     * including the name or signature of the referenced entity. This text
+     * provides human-readable context about the relationship and is used for
+     * display purposes within the generated documentation. Note that this
+     * property is not explicitly defined in the XML schema DTD but appears
+     * in practice within reference elements.
+     */
     text: string;
+    /**
+     * The unique reference identifier for the referenced entity.
+     *
+     * @remarks
+     * Mandatory attribute that provides a unique identifier for the entity
+     * being referenced. This identifier enables precise linking and cross-
+     * referencing between documentation elements, allowing navigation to the
+     * detailed documentation of the referenced item within the documentation
+     * structure.
+     */
     refid: string;
+    /**
+     * The starting line number where the reference occurs.
+     *
+     * @remarks
+     * Specifies the line number in the source code where the reference
+     * relationship begins. This location information enables precise source
+     * code navigation and helps establish the exact context of the reference
+     * within the original source files. Note that this attribute may be missing
+     * in some reference elements despite being defined as mandatory in the
+     * XML schema.
+     */
     startline: number | undefined;
+    /**
+     * The ending line number where the reference concludes.
+     *
+     * @remarks
+     * Specifies the line number in the source code where the reference
+     * relationship ends. Combined with the starting line, this provides a
+     * complete range for the reference occurrence, enabling precise source
+     * code highlighting and navigation capabilities. Note that this attribute
+     * may be missing in some reference elements despite being defined as
+     * mandatory in the XML schema.
+     */
     endline: number | undefined;
+    /**
+     * The compound reference identifier for the containing entity.
+     *
+     * @remarks
+     * Optional attribute that provides the identifier of the compound entity
+     * (such as a class or namespace) that contains the referenced item. This
+     * additional context enables more precise navigation and helps establish
+     * the hierarchical relationship between the referencing and referenced
+     * entities within the documentation structure.
+     */
     compoundref?: string | undefined;
+    /**
+     * Constructs a new abstract reference type from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance
+     * @param element - The XML element containing reference relationship data
+     * @param elementName - The expected XML element name
+     *
+     * @remarks
+     * Parses the provided XML element to construct a complete reference
+     * relationship data model. The parsing process extracts the textual content
+     * from the element and processes all defined attributes including the
+     * mandatory refid attribute, line number information, and optional compound
+     * reference data. Validation ensures that the reference identifier is
+     * present, maintaining the integrity of the reference relationship
+     * documentation.
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for reference type data models.
+ *
+ * @remarks
+ * Represents the foundational structure for reference elements within Doxygen
+ * XML documentation, corresponding to the refType complex type in the XML
+ * schema. This class manages references to various documented entities such
+ * as classes, namespaces, files, folders, modules, pages, and groups. Each
+ * reference includes the entity name, a unique identifier for linking, and
+ * optional protection and inline attributes. All concrete reference
+ * implementations should extend this base to ensure consistent structure
+ * and parsing behaviour across different reference types.
+ *
  * @public
  */
 export declare abstract class AbstractRefType extends AbstractDataModelBase {
+    /**
+     * The name of the referenced entity.
+     *
+     * @remarks
+     * Mandatory element containing the textual name of the referenced entity,
+     * passed as the element's text content. This name provides human-readable
+     * identification of the referenced item and is used for display and
+     * navigation purposes within the generated documentation.
+     */
     text: string;
+    /**
+     * The unique reference identifier for the referenced entity.
+     *
+     * @remarks
+     * Mandatory attribute that provides a unique identifier for the referenced
+     * entity within the Doxygen documentation system. This identifier enables
+     * precise linking and cross-referencing between documentation elements,
+     * allowing navigation to the detailed documentation of the referenced item.
+     */
     refid: string;
+    /**
+     * The protection level of the referenced entity.
+     *
+     * @remarks
+     * Optional attribute specifying the protection level according to the
+     * DoxProtectionKind enumeration. Values include 'public', 'protected',
+     * 'private', and 'package', indicating the accessibility scope of the
+     * referenced entity within its containing context.
+     */
     prot?: string | undefined;
+    /**
+     * Indicates whether the referenced entity is inline.
+     *
+     * @remarks
+     * Optional boolean attribute that specifies whether the referenced entity
+     * is defined inline within its containing context. This information affects
+     * how the entity is presented and processed in the generated documentation,
+     * particularly for inline classes, functions, or other code constructs.
+     */
     inline?: boolean | undefined;
+    /**
+     * Constructs a new abstract reference type from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance
+     * @param element - The XML element containing reference data
+     * @param elementName - The expected XML element name
+     *
+     * @remarks
+     * Parses the provided XML element to construct a complete reference data
+     * model. The parsing process extracts the textual content from the element
+     * and processes all defined attributes including the mandatory refid and
+     * optional protection and inline attributes. Validation ensures that both
+     * the reference name and identifier are present and non-empty, maintaining
+     * the integrity of the reference documentation.
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for reimplement type data models.
+ *
+ * @remarks
+ * Represents the foundational structure for reimplement relationship elements
+ * within Doxygen XML documentation, corresponding to the reimplementType
+ * complex type in the XML schema. This class manages relationships between
+ * methods, functions, or other documented entities that implement or override
+ * behaviour from base classes or interfaces. The reimplement relationship
+ * captures both the descriptive text and the reference identifier for the
+ * related entity, enabling comprehensive documentation of inheritance and
+ * polymorphic behaviours within the codebase.
+ *
  * @public
  */
 export declare abstract class AbstractReimplementType extends AbstractDataModelBase {
+    /**
+     * The descriptive text content for this reimplement relationship.
+     *
+     * @remarks
+     * Mandatory element containing the textual description of the reimplement
+     * relationship. This text typically includes the signature or name of the
+     * reimplemented entity, providing human-readable context about the
+     * relationship between the current entity and the referenced implementation.
+     */
     text: string;
+    /**
+     * The reference identifier for the reimplemented entity.
+     *
+     * @remarks
+     * Mandatory attribute that provides a unique identifier for the entity
+     * being reimplemented. This reference enables linking and cross-referencing
+     * between related documentation elements, allowing navigation between
+     * implementations and their base declarations within the generated
+     * documentation structure.
+     */
     refId: string;
+    /**
+     * Constructs a new abstract reimplement type from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance
+     * @param element - The XML element containing reimplement relationship data
+     * @param elementName - The expected XML element name
+     *
+     * @remarks
+     * Parses the provided XML element to construct a complete reimplement
+     * relationship data model. The parsing process extracts the textual content
+     * from the element and processes the mandatory refid attribute. Validation
+     * ensures that both the descriptive text and reference identifier are
+     * present and non-empty, maintaining the integrity of the reimplement
+     * relationship documentation.
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract class for XML-parsed section definition types.
+ *
+ * @remarks
+ * Extends the base section definition type to provide XML parsing capabilities
+ * for constructing section definition data models from Doxygen XML elements.
+ * This class handles the complete parsing process including attributes, inner
+ * elements, headers, descriptions, and member collections. All concrete
+ * section definition implementations that require XML parsing should extend
+ * this class to benefit from the standardised parsing infrastructure.
+ *
  * @public
  */
 export declare abstract class AbstractSectionDefType extends AbstractSectionDefTypeBase {
+    /**
+     * Constructs a new abstract section definition type from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance
+     * @param element - The XML element containing section definition data
+     * @param elementName - The expected XML element name
+     *
+     * @remarks
+     * Parses the provided XML element to construct a complete section definition
+     * data model. The parsing process handles all defined inner elements
+     * including headers, descriptions, member definitions, and member references,
+     * as well as the mandatory kind attribute. Validation ensures that required
+     * elements and attributes are present and conform to the expected XML schema
+     * structure.
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for section definition type data models.
+ *
+ * @remarks
+ * Represents the foundational structure for section definition elements
+ * within Doxygen XML documentation, corresponding to the sectiondefType
+ * complex type in the XML schema. This class provides the core properties
+ * and utility methods for managing section definitions, including kind
+ * classification, optional headers and descriptions, and member collections.
+ * All concrete section definition classes should extend this base to ensure
+ * consistent structure and behaviour.
+ *
  * @public
  */
 export declare abstract class AbstractSectionDefTypeBase extends AbstractDataModelBase {
+    /**
+     * The kind classification of this section definition.
+     *
+     * @remarks
+     * Mandatory attribute that specifies the type of section, corresponding
+     * to the DoxSectionKind enumeration in the XML schema. This classification
+     * determines how the section is processed and presented in the documentation.
+     */
     kind: string;
+    /**
+     * The optional header text for this section.
+     *
+     * @remarks
+     * Optional element that provides a title or heading for the section.
+     * When present, this header is used for display and navigation purposes
+     * within the generated documentation.
+     */
     header?: string | undefined;
+    /**
+     * The optional description content for this section.
+     *
+     * @remarks
+     * Optional element containing detailed description information for the
+     * section. This description provides context and documentation about
+     * the section's purpose and contents.
+     */
     description?: DescriptionDataModel | undefined;
+    /**
+     * Collection of member definition data models.
+     *
+     * @remarks
+     * Optional array containing detailed member definitions for this section.
+     * This collection is mutually exclusive with the members array, as per
+     * the XML schema choice constraint. Each member definition provides
+     * comprehensive information about documented entities.
+     */
     memberDefs?: MemberDefDataModel[] | undefined;
+    /**
+     * Collection of member reference data models.
+     *
+     * @remarks
+     * Optional array containing member references for this section. This
+     * collection is mutually exclusive with the memberDefs array, as per
+     * the XML schema choice constraint. Each member reference provides
+     * summary information and links to detailed definitions.
+     */
     members?: MemberDataModel[] | undefined;
+    /**
+     * Constructs a new abstract section definition type base instance.
+     *
+     * @param elementName - The XML element name for this section definition
+     * @param kind - The section kind classification
+     *
+     * @remarks
+     * Initialises the base properties for a section definition, establishing
+     * the element name and kind classification that will be used throughout
+     * the processing lifecycle.
+     */
     constructor(elementName: string, kind: string);
+    /**
+     * Determines whether this section contains any member information.
+     *
+     * @returns True if the section has member definitions or member references
+     *
+     * @remarks
+     * Utility method that checks for the presence of either member definitions
+     * or member references within this section. This is useful for determining
+     * whether the section requires member processing or can be treated as
+     * documentation-only content.
+     */
     hasMembers(): boolean;
+    /**
+     * Computes an adjusted kind string based on section and member suffixes.
+     *
+     * @param sectionSuffix - The suffix to apply for section-based adjustments
+     * @param memberSuffix - The suffix to apply for member-based adjustments
+     * @returns The adjusted kind string
+     *
+     * @remarks
+     * Transforms the section kind for specific member types, such as converting
+     * 'public-func' into more specific kinds like 'public-constructor',
+     * 'public-destructor', or 'public-operator'. For user-defined sections,
+     * returns the member suffix directly. For hyphenated kinds, replaces the
+     * final component with the section suffix. Otherwise, returns the member
+     * suffix as the default behaviour.
+     */
     computeAdjustedKind(sectionSuffix: string, memberSuffix?: string): string;
 }
 
 /**
+ * Abstract base class for table of contents kind type data models.
+ *
+ * @remarks
+ * Represents table of contents kind elements within Doxygen XML structures,
+ * corresponding to the tableofcontentsKindType complex type in the XML
+ * schema. This class handles the parsing of named table of contents sections
+ * with references and optional nested table of contents structures. All
+ * concrete table of contents kind data model classes should extend this
+ * abstract base to ensure consistent parsing and data representation.
+ *
  * @public
  */
 export declare abstract class AbstractTableOfContentsKindType extends AbstractDataModelBase {
+    /**
+     * The name of the table of contents section.
+     *
+     * @remarks
+     * Mandatory element extracted from the XML structure that provides
+     * the display name or title for this table of contents section.
+     * This name is used for navigation and presentation purposes.
+     */
     name: string;
+    /**
+     * The reference identifier for this table of contents section.
+     *
+     * @remarks
+     * Mandatory element that provides a reference or link target for
+     * this table of contents section. This reference is used to create
+     * navigation links and cross-references within the documentation.
+     */
     reference: string;
+    /**
+     * Collection of nested table of contents data models.
+     *
+     * @remarks
+     * Optional array containing nested table of contents elements that
+     * create hierarchical documentation structures. This allows for
+     * multi-level table of contents organisation with subsections and
+     * sub-subsections as needed.
+     */
     tableOfContents: TableOfContentsDataModel[] | undefined;
+    /**
+     * Constructs a new AbstractTableOfContentsKindType instance from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML elements
+     * @param element - The XML element containing the table of contents kind data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * Parses the provided XML element to extract table of contents kind
+     * information including mandatory name and reference elements, along with
+     * optional nested table of contents structures. The constructor handles
+     * unknown 'docs' elements that may appear but are not defined in the DTD.
+     * This element type has no attributes as per the XML schema.
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for table of contents type data models.
+ *
+ * @remarks
+ * Represents table of contents elements within Doxygen XML structures,
+ * corresponding to the tableofcontentsType complex type in the XML schema.
+ * This class handles the parsing of table of contents structures with
+ * mutually exclusive content choices: either table of contents sections
+ * or nested table of contents elements. All concrete table of contents
+ * data model classes should extend this abstract base to ensure consistent
+ * parsing and data representation.
+ *
  * @public
  */
 export declare abstract class AbstractTableOfContentsType extends AbstractDataModelBase {
+    /**
+     * Collection of table of contents section data models.
+     *
+     * @remarks
+     * Optional array containing table of contents section elements, part
+     * of an exclusive choice with tableOfContents. Each section represents
+     * a specific part of the documentation structure with its own name,
+     * reference, and potentially nested content.
+     */
     tocSect: TocSectDataModel[] | undefined;
+    /**
+     * Collection of nested table of contents data models.
+     *
+     * @remarks
+     * Optional array containing nested table of contents elements, part
+     * of an exclusive choice with tocSect. This allows for recursive
+     * table of contents structures to represent complex documentation
+     * hierarchies.
+     */
     tableOfContents: TableOfContentsDataModel[] | undefined;
+    /**
+     * Constructs a new AbstractTableOfContentsType instance from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML elements
+     * @param element - The XML element containing the table of contents data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * Parses the provided XML element to extract table of contents information
+     * following the exclusive choice pattern defined in the XML schema. The
+     * constructor processes either table of contents sections or nested table
+     * of contents elements, but not both, maintaining the mutually exclusive
+     * relationship. This element type has no attributes as per the schema.
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Abstract base class for template parameter list type data models.
+ *
+ * @remarks
+ * Represents template parameter list elements within Doxygen XML structures,
+ * corresponding to the templateparamlistType complex type in the XML schema.
+ * This class handles the parsing of parameter collections for templated
+ * constructs such as template classes and functions. All concrete template
+ * parameter list data model classes should extend this abstract base to
+ * ensure consistent parsing and data representation.
+ *
  * @public
  */
 export declare abstract class AbstractTemplateParamListType extends AbstractDataModelBase {
+    /**
+     * Collection of parameter data models within this template parameter list.
+     *
+     * @remarks
+     * Optional array containing parameter elements found within the template
+     * parameter list structure. Each parameter represents a template parameter
+     * definition including its type, name, and other attributes. The array
+     * supports zero to many parameters as per the XML schema, accommodating
+     * both non-templated constructs and complex template declarations.
+     */
     params?: ParamDataModel[] | undefined;
+    /**
+     * Constructs a new AbstractTemplateParamListType instance from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML elements
+     * @param element - The XML element containing the template parameter list
+     * data
+     * @param elementName - The name of the XML element being processed
+     *
+     * @remarks
+     * Parses the provided XML element to extract template parameter list
+     * information including parameter collections. The constructor processes
+     * parameter elements into ParamDataModel instances when present. This
+     * element type has no attributes as per the XML schema definition,
+     * containing only parameter child elements.
+     */
     constructor(xml: DoxygenXmlParser, element: object, elementName: string);
 }
 
 /**
+ * Data model for base compound references in inheritance relationships.
+ *
+ * @remarks
+ * Represents references to base classes or parent compounds in inheritance
+ * hierarchies as documented by Doxygen. This class handles the
+ * 'basecompoundref' XML elements that establish parent-child relationships
+ * in object-oriented documentation structures.
+ *
  * @public
  */
 export declare class BaseCompoundRefDataModel extends AbstractCompoundRefType {
+    /**
+     * Constructs a new BaseCompoundRefDataModel instance.
+     *
+     * @remarks
+     * Creates a data model object for 'basecompoundref' XML elements,
+     * representing inheritance relationships where the current compound
+     * derives from the referenced base compound.
+     *
+     * @param xml - The XML parser instance for processing elements
+     * @param element - The XML element object to parse
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * 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 declare 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: DoxygenXmlParser, element: object);
 }
 
 /**
- * Options, as written by the user. All are optional.
+ * Configuration options as specified by users in configuration files.
+ *
+ * @remarks
+ * All options are optional and can be either string or boolean values
+ * depending on the specific configuration property.
  *
  * @public
  */
 declare type CliConfigurationOptions = Record<string, string | boolean>;
 
 /**
- * Options, as seen by the application. Most are mandatory.
+ * Comprehensive CLI options class for documentation generation configuration.
+ *
+ * @remarks
+ * The CliOptions class contains all configuration parameters that control
+ * the behaviour of the doxygen2docusaurus conversion process, including
+ * paths, URLs, styling, and feature toggles.
  *
  * @public
  */
 export declare class CliOptions {
     /**
-     * Relative to the current website folder, like `doxygen/xml`, no initial/
-     * final slashes.
+     * Path to the Doxygen XML input folder relative to the website folder.
+     *
+     * @remarks
+     * Specifies the location of XML files generated by Doxygen, typically
+     * containing the parsed documentation data. Path should not include
+     * initial or final slashes.
+     *
+     * @defaultValue 'doxygen/xml'
      */
     doxygenXmlInputFolderPath: string;
     /**
-     * Relative to the current website folder, like `docs`, no initial/final
-     * slashes.
+     * Path to the documentation folder relative to the website folder.
+     *
+     * @remarks
+     * Defines the base folder where generated documentation will be placed
+     * within the Docusaurus website structure. Path should not include
+     * initial or final slashes.
+     *
+     * @defaultValue 'docs'
      */
     docsFolderPath: string;
-    /** Relative to the docs folder, like `api`, no initial/final slashes. */
+    /**
+     * Path to the API documentation folder relative to the docs folder.
+     *
+     * @remarks
+     * Specifies the subfolder within the docs folder where API reference
+     * documentation will be generated. Path should not include initial
+     * or final slashes.
+     *
+     * @defaultValue 'api'
+     */
     apiFolderPath: string;
-    /** Site base URL, like / or /xxx/. */
+    /**
+     * Base URL for the entire website.
+     *
+     * @remarks
+     * Defines the root URL path for the website, typically '/' for root
+     * deployment or '/project-name/' for GitHub Pages or similar hosting.
+     *
+     * @defaultValue '/'
+     */
     baseUrl: string;
-    /** Relative to the web home, like `docs`, without initial/final slashes. */
+    /**
+     * URL path to the documentation section relative to the website root.
+     *
+     * @remarks
+     * Specifies the URL segment that leads to the documentation section,
+     * without initial or final slashes. Used for navigation and linking.
+     *
+     * @defaultValue 'docs'
+     */
     docsBaseUrl: string;
-    /** Relative to the docs home, like `api`, without initial/final slashes. */
+    /**
+     * URL path to the API documentation relative to the docs section.
+     *
+     * @remarks
+     * Defines the URL segment for API documentation within the docs section,
+     * without initial or final slashes. Used for generating navigation links.
+     *
+     * @defaultValue 'api'
+     */
     apiBaseUrl: string;
-    /** Relative to `static` */
+    /**
+     * Path for images relative to the `static` folder.
+     *
+     * @remarks
+     * Specifies where Doxygen-generated images will be stored within the
+     * Docusaurus static assets folder structure.
+     *
+     * @defaultValue 'assets/images/doxygen'
+     */
     imagesFolderPath: string;
-    /**  Relative to the current `website/static` folder, like `reference`. */
+    /**
+     * Output folder for compatibility redirect files.
+     *
+     * @remarks
+     * Optional path relative to the website/static folder where HTML redirect
+     * files will be generated to maintain compatibility with original Doxygen
+     * URLs. When undefined, no redirect files are created.
+     */
     compatibilityRedirectsOutputFolderPath?: string | undefined;
-    /** The title to be displayed on the main page. */
+    /**
+     * Title displayed on the main API documentation page.
+     *
+     * @remarks
+     * When specified, this title overrides the default title generated from
+     * the project brief. When empty, the title is automatically constructed
+     * from the project configuration.
+     *
+     * @defaultValue ''
+     */
     mainPageTitle: string;
     /**
-     * Relative to the current website folder, default
-     * `sidebar-category-doxygen.json`.
+     * Path to the sidebar category configuration file.
+     *
+     * @remarks
+     * Specifies the location where the generated sidebar category JSON
+     * configuration will be written, relative to the current website folder.
+     *
+     * @defaultValue 'sidebar-category-doxygen.json'
      */
     sidebarCategoryFilePath: string;
-    /** Short text to be displayed in the sidebar. */
+    /**
+     * Label displayed in the Docusaurus sidebar for the API documentation.
+     *
+     * @remarks
+     * Short descriptive text that appears in the sidebar navigation to
+     * identify the API reference section.
+     *
+     * @defaultValue 'API Reference (Doxygen)'
+     */
     sidebarCategoryLabel: string;
     /**
-     * Relative to the current website folder, default
-     * `docusaurus-config-doxygen-menu-dropdown.json`.
+     * Path to the navbar configuration file.
+     *
+     * @remarks
+     * Specifies the location where the generated navbar dropdown JSON
+     * configuration will be written, relative to the current website folder.
+     *
+     * @defaultValue 'docusaurus-config-navbar-doxygen.json'
+     */
+    navbarFilePath: string;
+    /**
+     * Label displayed in the top navigation bar.
+     *
+     * @remarks
+     * Short text that appears in the Docusaurus top navigation bar to
+     * provide access to the API documentation section.
+     *
+     * @defaultValue 'Reference'
+     */
+    navbarLabel: string;
+    /**
+     * Position of the navigation menu in the top bar.
+     *
+     * @remarks
+     * Determines whether the API documentation menu appears on the left
+     * or right side of the Docusaurus navigation bar.
+     *
+     * @defaultValue 'left'
      */
-    menuDropdownFilePath: string;
-    /** Short text to be displayed in the menu. */
-    menuDropdownLabel: string;
+    navbarPosition: 'left' | 'right';
     /**
-     * Relative to the current website folder, default
-     * `src/css/custom-doxygen.css`
+     * Path to the custom CSS file for styling overrides.
+     *
+     * @remarks
+     * Specifies the location where custom CSS styles will be written to
+     * provide Doxygen-specific styling within the Docusaurus theme.
+     * Path is relative to the current website folder.
+     *
+     * @defaultValue 'src/css/custom-doxygen2docusaurus.css'
      */
     customCssFilePath: string;
-    /** Boolean to control verbosity. */
+    /**
+     * Controls verbose output during the conversion process.
+     *
+     * @remarks
+     * When enabled, provides detailed logging information about the
+     * conversion process, including file processing status and statistics.
+     *
+     * @defaultValue false
+     */
     verbose: boolean;
-    /** Boolean to control debug verbosity. */
+    /**
+     * Controls debug-level output during the conversion process.
+     *
+     * @remarks
+     * When enabled, provides extensive debugging information useful for
+     * troubleshooting issues. Automatically enables verbose output as well.
+     *
+     * @defaultValue false
+     */
     debug: boolean;
-    /** Boolean to control if the TODO suggestions are shown. */
+    /**
+     * Controls whether TODO suggestion descriptions are displayed.
+     *
+     * @remarks
+     * When enabled, shows suggestions for improvements or missing content
+     * that could enhance the generated documentation quality.
+     *
+     * @defaultValue false
+     */
     suggestToDoDescriptions: boolean;
-    /** Boolean to render the pages to the top. */
-    renderPagesAtTop: boolean;
-    /** Boolean to render the program listing in the File pages. */
+    /**
+     * Controls whether pages are listed at the top of the sidebar.
+     *
+     * @remarks
+     * When enabled, places page links prominently at the top of the sidebar
+     * navigation structure for easier access to important pages.
+     *
+     * @defaultValue true
+     */
+    listPagesAtTop: boolean;
+    /**
+     * Controls program listing rendering in File pages.
+     *
+     * @remarks
+     * When enabled, includes syntax-highlighted source code listings
+     * within the generated File documentation pages.
+     *
+     * @defaultValue true
+     */
     renderProgramListing: boolean;
     /**
-     * Boolean to render the program listing in the member definitions sections.
+     * Controls program listing rendering in member definition sections.
+     *
+     * @remarks
+     * When enabled, includes inline syntax-highlighted code snippets
+     * within member documentation sections for better context.
+     *
+     * @defaultValue true
      */
     renderProgramListingInline: boolean;
     /**
-     * Location of original Doxygen pages
+     * Note about the location of original Doxygen pages.
      *
-     * 'For comparison, the original Doxygen html pages, styled with the
-     * <a href="https://jothepro.github.io/doxygen-awesome-css/">doxygen-awesome-css</a>
-     * plugin, continue to be available via the
-     * <a href="pathname:///doxygen/topics.html"><code>.../doxygen/*.html</b></code>
-     * URLs.'
+     * @remarks
+     * Provides information about where to find the original Doxygen HTML
+     * pages for comparison purposes. When populated, this note is displayed
+     * to inform users about the availability of alternative documentation
+     * formats.
      */
     originalPagesNote: string;
-    /** String identifier in case of multiple instances. */
+    /**
+     * String identifier for distinguishing multiple configuration instances.
+     *
+     * @remarks
+     * Used when multiple configuration instances exist to provide unique
+     * identification. Particularly useful in multi-configuration scenarios
+     * where different settings need to be applied to different outputs.
+     *
+     * @defaultValue 'default'
+     */
     id: string;
+    /**
+     * Creates a new CliOptions instance with the specified command options.
+     *
+     * @remarks
+     * Initialises the configuration object by setting the ID and optional
+     * flags like verbose and debug. When the ID is not 'default', adjusts
+     * folder paths and file names to include the ID for multi-configuration
+     * scenarios.
+     *
+     * @param commandOptions - Command-line options object containing ID and flags
+     */
     constructor(commandOptions: CommandOptions);
+    /**
+     * Parses configuration options from various JSON configuration sources.
+     *
+     * @remarks
+     * Attempts to load configuration from multiple locations in order of
+     * preference: config/doxygen2docusaurus.json, doxygen2docusaurus.json,
+     * and package.json. Validates required properties and enables debug
+     * output if requested.
+     *
+     * @throws Assertion error if required configuration properties are missing
+     */
     parse(): Promise<void>;
+    /**
+     * Selects the appropriate configuration from multi-configuration options.
+     *
+     * @remarks
+     * When using a specific ID, returns the corresponding configuration.
+     * For the default ID, returns either the 'default' configuration or
+     * treats the entire object as a single configuration.
+     *
+     * @param multiConfigurations - Configuration object or multi-config map
+     * @returns Selected configuration options or undefined if not found
+     */
     selectMultiConfiguration(multiConfigurations: CliConfigurationOptions | MultiConfigurations): CliConfigurationOptions | undefined;
 }
 
 /**
+ * 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 declare 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: DoxygenXmlParser, element: object);
 }
 
+/**
+ * Command line argument options passed to the application.
+ *
+ * @remarks
+ * Represents the parsed command line arguments with flexible typing
+ * to accommodate various option formats and undefined values.
+ *
+ * @public
+ */
 declare type CommandOptions = Record<string, string | boolean | undefined>;
 
 /**
+ * Concrete implementation of compound definition data model.
+ *
+ * @remarks
+ * Provides the primary data model implementation for Doxygen compound
+ * definitions, handling all types of compounds including classes, structures,
+ * files, namespaces, and pages. This class serves as the main entry point
+ * for processing compound definition XML elements in the Doxygen output.
+ *
  * @public
  */
 export declare class CompoundDefDataModel extends AbstractCompoundDefType {
+    /**
+     * Constructs a new CompoundDefDataModel instance.
+     *
+     * @remarks
+     * Creates a data model object for 'compounddef' XML elements by delegating
+     * to the parent constructor with the appropriate element name. This
+     * represents the root element for all compound definitions in Doxygen XML
+     * output.
+     *
+     * @param xml - The XML parser instance for processing elements
+     * @param element - The XML element object to parse
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Top-level data model class for orchestrating Doxygen XML parsing and data
+ * organisation.
+ *
+ * @remarks
+ * This class serves as the primary entry point for parsing Doxygen-generated
+ * XML files and constructing a comprehensive data model. It coordinates the
+ * parsing of index files, compound definitions, and configuration files,
+ * maintaining references to all parsed content for subsequent processing.
+ * The class provides methods for sequential parsing operations and ensures
+ * data integrity throughout the parsing workflow.
+ *
  * @public
  */
 export declare class DataModel {
     /**
-     * The global configuration options.
+     * The global configuration options for the parsing operation.
+     *
+     * @remarks
+     * Contains command-line interface options that control the behaviour of
+     * the parser and influence how XML files are processed and data models
+     * are constructed.
      */
     options: CliOptions;
+    /**
+     * The XML parser instance used for processing Doxygen XML files.
+     *
+     * @remarks
+     * Provides low-level XML parsing functionality and utility methods for
+     * extracting elements, attributes, and text content from the parsed XML
+     * structure.
+     */
     xml: DoxygenXmlParser;
     /**
-     * Keep track of the number of XML files parsed.
+     * Counter tracking the number of XML files successfully parsed.
+     *
+     * @remarks
+     * Incremented for each XML file processed during the parsing operation,
+     * providing metrics for progress monitoring and diagnostic reporting.
      *
      * @defaultValue 0
      */
     parsedFilesCounter: number;
+    /**
+     * The parsed Doxygen index data model from the main index XML file.
+     *
+     * @remarks
+     * Contains the top-level index structure that references all compound
+     * definitions and provides the navigation structure for the documentation.
+     * Populated during the initial parsing phase from `index.xml`.
+     */
     doxygenindex?: DoxygenIndexDataModel;
+    /**
+     * Collection of compound definition data models parsed from individual XML
+     * files.
+     *
+     * @remarks
+     * Each compound definition represents a documented entity such as a class,
+     * namespace, or file, along with its members and associated documentation.
+     * Populated by parsing XML files referenced in the index.
+     */
     compoundDefs: CompoundDefDataModel[];
+    /**
+     * The parsed Doxyfile configuration data model.
+     *
+     * @remarks
+     * Contains the Doxygen configuration options and settings that influenced
+     * the generation of the XML documentation. Parsed from `Doxyfile.xml` if
+     * present in the input folder.
+     */
     doxyfile?: DoxygenFileDataModel;
+    /**
+     * The project version string extracted from the documentation metadata.
+     *
+     * @remarks
+     * Optional version identifier for the documented project, typically derived
+     * from the Doxygen configuration or project metadata during parsing.
+     */
     projectVersion?: string;
+    /**
+     * Constructs a new DataModel instance with the specified configuration
+     * options.
+     *
+     * @param options - The command-line interface options for controlling parsing
+     * behaviour
+     *
+     * @remarks
+     * Initialises the data model with the provided configuration options and
+     * creates a new DoxygenXmlParser instance for XML processing. The compound
+     * definitions array is initialised as empty and will be populated during
+     * the parsing phase.
+     */
     constructor(options: CliOptions);
+    /**
+     * Orchestrates the complete parsing of Doxygen XML files and data model
+     * construction.
+     *
+     * @remarks
+     * This method performs the complete parsing workflow in sequential phases:
+     * parsing the main index file, processing all referenced compound XML files,
+     * and parsing the Doxyfile configuration. It maintains the original XML
+     * element order and content fidelity throughout the process. Progress
+     * information is logged to the console, with detailed output in verbose mode.
+     */
     parse(): Promise<void>;
     /**
      * Parses the main Doxygen index XML file and initialises the index data
@@ -603,57 +3338,206 @@ export declare class DataModel {
 }
 
 /**
+ * Data model for default value elements within documentation content.
+ *
+ * @remarks
+ * Represents default value elements that contain parameter default values
+ * within function and method documentation. This implementation processes
+ * Doxygen's defval elements, which contain mixed text and reference content
+ * describing the default values assigned to function parameters when no
+ * explicit value is provided during function calls.
+ *
+ * The linked text structure enables cross-references to constants, enums,
+ * and other symbols used within default value expressions.
+ *
  * @public
  */
 export declare class DefValDataModel extends AbstractLinkedTextType {
+    /**
+     * Constructs a DefValDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the default value data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractLinkedTextType to
+     * handle linked text processing whilst identifying the element as 'defval'
+     * for proper XML schema compliance and default value content processing.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Data model for derived compound references in inheritance relationships.
+ *
+ * @remarks
+ * Represents references to derived classes or child compounds in inheritance
+ * hierarchies as documented by Doxygen. This class handles the
+ * 'derivedcompoundref' XML elements that establish child-parent relationships
+ * in object-oriented documentation structures.
+ *
  * @public
  */
 export declare class DerivedCompoundRefDataModel extends AbstractCompoundRefType {
+    /**
+     * Constructs a new DerivedCompoundRefDataModel instance.
+     *
+     * @remarks
+     * Creates a data model object for 'derivedcompoundref' XML elements,
+     * representing inheritance relationships where other compounds derive
+     * from the current compound as their base.
+     *
+     * @param xml - The XML parser instance for processing elements
+     * @param element - The XML element object to parse
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * 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 declare 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: DoxygenXmlParser, element: object);
 }
 
 /**
  * @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 declare 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: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Concrete data model class for doxyfile elements.
+ *
+ * @remarks
+ * Represents the root element of Doxyfile XML configuration files,
+ * extending the abstract base class to provide specific handling for
+ * 'doxyfile' elements. This class serves as the primary entry point
+ * for parsing Doxygen configuration files and provides access to all
+ * configuration options and metadata contained within the file structure.
+ *
  * @public
  */
 export declare class DoxygenFileDataModel extends AbstractDoxygenFileType {
+    /**
+     * Constructs a new DoxygenFileDataModel instance from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML elements
+     * @param element - The XML element containing the doxyfile data
+     *
+     * @remarks
+     * Initialises the Doxyfile data model by parsing the provided XML element
+     * as a 'doxyfile' element type. The constructor delegates to the parent
+     * class for common configuration processing whilst specifying the element
+     * name for proper XML structure handling.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Concrete data model class for Doxyfile option elements.
+ *
+ * @remarks
+ * Represents individual configuration option elements found within
+ * Doxyfile XML structures. This class extends the abstract base to
+ * provide specific handling for 'option' elements, which define
+ * individual Doxygen configuration settings including their identifiers,
+ * types, default status, and associated values. Each option corresponds
+ * to a specific configuration parameter that controls Doxygen's
+ * documentation generation behaviour.
+ *
  * @public
  */
 export declare class DoxygenFileOptionDataModel extends AbstractDoxygenFileOptionType {
+    /**
+     * Constructs a new DoxygenFileOptionDataModel instance from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML elements
+     * @param element - The XML element containing the option data
+     *
+     * @remarks
+     * Initialises the option data model by parsing the provided XML element
+     * as an 'option' element type. The constructor delegates to the parent
+     * class for common option processing whilst specifying the element name
+     * for proper XML structure handling.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Concrete data model class for doxygenindex elements.
+ *
+ * @remarks
+ * Represents the root element of Doxygen index XML files, extending the
+ * abstract base class to provide specific handling for 'doxygenindex'
+ * elements. This class serves as the primary entry point for parsing
+ * index files and provides access to all compound definitions and
+ * metadata contained within the index structure.
+ *
  * @public
  */
 export declare class DoxygenIndexDataModel extends AbstractIndexDoxygenType {
+    /**
+     * Constructs a new DoxygenIndexDataModel instance from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML elements
+     * @param element - The XML element containing the doxygenindex data
+     *
+     * @remarks
+     * Initialises the Doxygen index data model by parsing the provided XML
+     * element as a 'doxygenindex' element type. The constructor delegates
+     * to the parent class for common processing whilst specifying the
+     * element name for proper XML structure handling.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
- * The DoxygenXmlParser class is responsible for parsing
- * Doxygen-generated XML files and constructing the internal data model.
+ * XML parser for Doxygen-generated documentation files.
  *
  * @remarks
  * This class initialises the XML parser with options that preserve the order
@@ -661,6 +3545,9 @@ export declare class DoxygenIndexDataModel extends AbstractIndexDoxygenType {
  * for documentation purposes. It maintains a counter for the number of files
  * parsed and stores the resulting data model.
  *
+ * The parser is configured to handle Doxygen's specific XML format whilst
+ * maintaining fidelity to the source structure and content organisation.
+ *
  * @example
  * ```typescript
  * const parser = new DoxygenXmlParser({ options });
@@ -671,13 +3558,29 @@ export declare class DoxygenIndexDataModel extends AbstractIndexDoxygenType {
  */
 export declare class DoxygenXmlParser {
     /**
-     * The global configuration options.
+     * The global configuration options for the parsing operation.
+     *
+     * @remarks
+     * Contains the command-line interface options that control the behaviour
+     * of the parser throughout the XML processing workflow.
      */
     options: CliOptions;
     /**
-     * The XML parser instance configured for Doxygen XML.
+     * The XML parser instance configured specifically for Doxygen XML format.
+     *
+     * @remarks
+     * Configured with settings that preserve element order, remove namespace
+     * prefixes, and maintain fidelity to the original XML structure for
+     * accurate data model construction.
      */
     xmlParser: XMLParser;
+    /**
+     * Collection of image references extracted during XML parsing.
+     *
+     * @remarks
+     * Accumulates image elements found in the documentation content,
+     * allowing for centralised image processing and reference management.
+     */
     images: AbstractDocImageType[];
     /**
      * Constructs a new instance of the DoxygenXmlParser class.
@@ -688,9 +3591,8 @@ export declare class DoxygenXmlParser {
      * This constructor initialises the XML parser with settings that preserve the
      * order and structure of the original XML content, remove namespace prefixes,
      * and ensure that both tag and attribute values are parsed. The values are
-     * not
-     * trimmed, maintaining fidelity to the source XML. The provided options are
-     * stored for use throughout the parsing process.
+     * not trimmed, maintaining fidelity to the source XML. The provided options
+     * are stored for use throughout the parsing process.
      */
     constructor(options: CliOptions);
     /**
@@ -909,120 +3811,486 @@ export declare class DoxygenXmlParser {
 }
 
 /**
+ * Concrete implementation of enumeration value data model.
+ *
+ * @remarks
+ * Represents a single enumeration value as parsed from Doxygen XML
+ * output. Inherits all functionality from the abstract base class
+ * and provides the specific element name for parsing.
+ *
  * @public
  */
 export declare class EnumValueDataModel extends AbstractEnumValueType {
+    /**
+     * Creates a new enumeration value data model from XML.
+     *
+     * @remarks
+     * Parses the XML element representing an enumeration value using
+     * the inherited parsing logic with the 'enumvalue' element name.
+     *
+     * @param xml - The XML parser instance
+     * @param element - The XML element to parse
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * 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 declare 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: DoxygenXmlParser, element: object);
 }
 
 /**
+ * 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 declare 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: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Data model for includedby elements within documentation content.
+ *
+ * @remarks
+ * Represents includedby elements that document files which include the
+ * current source file. This implementation processes Doxygen's includedby
+ * elements, which contain information about files that incorporate the
+ * current file through preprocessor directives, establishing reverse
+ * inclusion relationships within the documentation system.
+ *
+ * The includedby relationship indicates a dependency where other files
+ * incorporate content from the current file during compilation.
+ *
  * @public
  */
 export declare class IncludedByDataModel extends AbstractIncType {
+    /**
+     * Constructs an IncludedByDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the includedby data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractIncType to handle
+     * include processing whilst identifying the element as 'includedby' for
+     * proper XML schema compliance and reverse include relationship handling.
+     * The processed data represents files that include the current source file
+     * through preprocessor directives, establishing dependency relationships.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Data model for includes elements within documentation content.
+ *
+ * @remarks
+ * Represents includes elements that document files included by the current
+ * source file. This implementation processes Doxygen's includes elements,
+ * which contain information about files that are included through preprocessor
+ * directives such as #include statements within the documented source code.
+ *
+ * The includes relationship indicates a dependency where the current file
+ * incorporates content from the referenced file during compilation.
+ *
  * @public
  */
 export declare class IncludesDataModel extends AbstractIncType {
+    /**
+     * Constructs an IncludesDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the includes data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractIncType to handle
+     * include processing whilst identifying the element as 'includes' for
+     * proper XML schema compliance and include relationship documentation.
+     * The processed data represents files that are included by the current
+     * source file through preprocessor directives.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Concrete data model class for index compound elements.
+ *
+ * @remarks
+ * Represents individual compound elements found within Doxygen index XML
+ * structures. This class extends the abstract base to provide specific
+ * handling for 'compound' elements, which reference documented entities
+ * such as classes, namespaces, files, and other structural components
+ * within the indexed documentation. Each compound serves as an entry
+ * point for accessing detailed documentation in separate XML files.
+ *
  * @public
  */
 export declare class IndexCompoundDataModel extends AbstractIndexCompoundType {
+    /**
+     * Constructs a new IndexCompoundDataModel instance from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML elements
+     * @param element - The XML element containing the compound data
+     *
+     * @remarks
+     * Initialises the compound data model by parsing the provided XML element
+     * as a 'compound' element type. The constructor delegates to the parent
+     * class for common compound processing whilst specifying the element name
+     * for proper XML structure handling.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Concrete data model class for index member elements.
+ *
+ * @remarks
+ * Represents individual member elements found within Doxygen index XML
+ * structures. This class extends the abstract base to provide specific
+ * handling for 'member' elements, which reference documented members
+ * such as functions, variables, and other programming constructs within
+ * the indexed documentation.
+ *
  * @public
  */
 export declare class IndexMemberDataModel extends AbstractIndexMemberType {
+    /**
+     * Constructs a new IndexMemberDataModel instance from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML elements
+     * @param element - The XML element containing the member data
+     *
+     * @remarks
+     * Initialises the member data model by parsing the provided XML element
+     * as a 'member' element type. The constructor delegates to the parent
+     * class for common member processing whilst specifying the element name.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Data model for initializer elements within documentation content.
+ *
+ * @remarks
+ * Represents initializer elements that contain variable or member
+ * initialization expressions within source code documentation. This
+ * implementation processes Doxygen's initializer elements, which contain
+ * mixed text and reference content describing the initial values assigned
+ * to variables, constants, or class members.
+ *
+ * The linked text structure enables cross-references to types and symbols
+ * used within initialization expressions.
+ *
  * @public
  */
 export declare class InitializerDataModel extends AbstractLinkedTextType {
+    /**
+     * Constructs an InitializerDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the initializer data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractLinkedTextType to
+     * handle linked text processing whilst identifying the element as
+     * 'initializer' for proper XML schema compliance and initialization
+     * expression content processing.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Data model for inner class reference elements.
+ *
+ * @remarks
+ * Represents a reference to an inner class within Doxygen XML documentation,
+ * corresponding to the innerclass XML element. This class manages references
+ * to classes that are contained within the current documentation context,
+ * providing linking and navigation capabilities to detailed class
+ * documentation. Inner classes typically represent nested classes, inner
+ * types, or classes defined within other classes or namespaces.
+ *
  * @public
  */
 export declare class InnerClassDataModel extends AbstractRefType {
+    /**
+     * Constructs a new inner class reference data model from XML.
+     *
+     * @param xml - The Doxygen XML parser instance
+     * @param element - The XML element containing inner class reference data
+     *
+     * @remarks
+     * Creates a complete inner class reference data model by parsing the
+     * provided XML element. This constructor delegates to the parent class to
+     * handle all standard parsing operations for the innerclass element type,
+     * establishing the reference to the contained class entity.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Data model for inner folder reference elements.
+ *
+ * @remarks
+ * Represents a reference to an inner folder within Doxygen XML documentation,
+ * corresponding to the innerdir XML element. This class manages references
+ * to folders that are contained within the current documentation context,
+ * providing linking and navigation capabilities to detailed folder
+ * documentation. Inner folders typically represent subdirectories within
+ * the project structure that contain related source files and documentation.
+ *
  * @public
  */
 export declare class InnerDirDataModel extends AbstractRefType {
+    /**
+     * Constructs a new inner folder reference data model from XML.
+     *
+     * @param xml - The Doxygen XML parser instance
+     * @param element - The XML element containing inner folder reference data
+     *
+     * @remarks
+     * Creates a complete inner folder reference data model by parsing the
+     * provided XML element. This constructor delegates to the parent class to
+     * handle all standard parsing operations for the innerdir element type,
+     * establishing the reference to the contained folder entity.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Data model for inner file reference elements.
+ *
+ * @remarks
+ * Represents a reference to an inner file within Doxygen XML documentation,
+ * corresponding to the innerfile XML element. This class manages references
+ * to files that are contained within the current documentation context,
+ * providing linking and navigation capabilities to detailed file
+ * documentation. Inner files typically represent source code files, headers,
+ * or other documented files within the project structure.
+ *
  * @public
  */
 export declare class InnerFileDataModel extends AbstractRefType {
+    /**
+     * Constructs a new inner file reference data model from XML.
+     *
+     * @param xml - The Doxygen XML parser instance
+     * @param element - The XML element containing inner file reference data
+     *
+     * @remarks
+     * Creates a complete inner file reference data model by parsing the
+     * provided XML element. This constructor delegates to the parent class to
+     * handle all standard parsing operations for the innerfile element type,
+     * establishing the reference to the contained file entity.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Data model for inner group reference elements.
+ *
+ * @remarks
+ * Represents a reference to an inner group within Doxygen XML documentation,
+ * corresponding to the innergroup XML element. This class manages references
+ * to groups that are contained within the current documentation context,
+ * providing linking and navigation capabilities to detailed group
+ * documentation. Inner groups typically represent logical collections or
+ * modules of related functionality that are organised within the current
+ * documentation scope.
+ *
  * @public
  */
 export declare class InnerGroupDataModel extends AbstractRefType {
+    /**
+     * Constructs a new inner group reference data model from XML.
+     *
+     * @param xml - The Doxygen XML parser instance
+     * @param element - The XML element containing inner group reference data
+     *
+     * @remarks
+     * Creates a complete inner group reference data model by parsing the
+     * provided XML element. This constructor delegates to the parent class to
+     * handle all standard parsing operations for the innergroup element type,
+     * establishing the reference to the contained group entity.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Data model for inner namespace reference elements.
+ *
+ * @remarks
+ * Represents a reference to an inner namespace within Doxygen XML
+ * documentation, corresponding to the innernamespace XML element. This class
+ * manages references to namespaces that are contained within the current
+ * documentation context, providing linking and navigation capabilities to
+ * detailed namespace documentation. Inner namespaces typically represent
+ * nested namespaces or namespace aliases defined within other namespaces.
+ *
  * @public
  */
 export declare class InnerNamespaceDataModel extends AbstractRefType {
+    /**
+     * Constructs a new inner namespace reference data model from XML.
+     *
+     * @param xml - The Doxygen XML parser instance
+     * @param element - The XML element containing inner namespace reference data
+     *
+     * @remarks
+     * Creates a complete inner namespace reference data model by parsing the
+     * provided XML element. This constructor delegates to the parent class to
+     * handle all standard parsing operations for the innernamespace element
+     * type, establishing the reference to the contained namespace entity.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Data model for inner page reference elements.
+ *
+ * @remarks
+ * Represents a reference to an inner page within Doxygen XML documentation,
+ * corresponding to the innerpage XML element. This class manages references
+ * to pages that are contained within the current documentation context,
+ * providing linking and navigation capabilities to detailed page
+ * documentation. Inner pages typically represent documentation pages,
+ * tutorials, or other narrative content that is logically contained within
+ * the current documentation scope.
+ *
  * @public
  */
 export declare class InnerPageDataModel extends AbstractRefType {
+    /**
+     * Constructs a new inner page reference data model from XML.
+     *
+     * @param xml - The Doxygen XML parser instance
+     * @param element - The XML element containing inner page reference data
+     *
+     * @remarks
+     * Creates a complete inner page reference data model by parsing the
+     * provided XML element. This constructor delegates to the parent class to
+     * handle all standard parsing operations for the innerpage element type,
+     * establishing the reference to the contained page entity.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Concrete implementation for listofallmembers elements within compound
+ * documentation.
+ *
+ * @remarks
+ * Provides specific handling for listofallmembers XML elements that contain
+ * comprehensive member inventories within class and compound documentation.
+ * This implementation extends the abstract base class functionality to
+ * process the complete collection of member references, including both
+ * directly declared and inherited members.
+ *
+ * The class ensures proper instantiation of member reference data models
+ * whilst maintaining the hierarchical structure and accessibility information
+ * required for comprehensive documentation generation.
+ *
  * @public
  */
 export declare class ListOfAllMembersDataModel extends AbstractListOfAllMembersType {
+    /**
+     * Constructs a new listofallmembers data model instance.
+     *
+     * @param xml - The XML parser instance for processing elements
+     * @param element - The source XML element containing listofallmembers data
+     *
+     * @remarks
+     * Initialises the data model with the specific element name
+     * 'listofallmembers' and delegates processing to the abstract base class
+     * implementation. This ensures consistent handling of member reference
+     * collections whilst maintaining proper element identification.
+     *
+     * @public
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Concrete implementation for location elements within documentation.
+ *
+ * @remarks
+ * Provides specific handling for location XML elements that contain
+ * comprehensive source code positioning information. This implementation
+ * extends the abstract base class functionality to process location
+ * elements with the specific element name 'location'.
+ *
+ * The class ensures proper instantiation of location data models whilst
+ * maintaining all the detailed positioning information required for
+ * accurate source code navigation and reference generation.
+ *
  * @public
  */
 export declare class LocationDataModel extends AbstractLocationType {
+    /**
+     * Constructs a new location data model instance.
+     *
+     * @param xml - The XML parser instance for processing elements
+     * @param element - The source XML element containing location data
+     *
+     * @remarks
+     * Initialises the data model with the specific element name 'location'
+     * and delegates processing to the abstract base class implementation.
+     * This ensures consistent handling of location information whilst
+     * maintaining proper element identification.
+     *
+     * @public
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
  * Main entry point for the doxygen2docusaurus CLI tool.
  *
+ * @remarks
+ * Orchestrates the complete conversion process from Doxygen XML to Docusaurus
+ * documentation. Handles command-line argument parsing, configuration loading,
+ * data model creation, workspace initialisation, and documentation generation.
+ * Provides timing information and appropriate exit codes for integration.
+ *
  * @param argv - Command line arguments array
  * @returns Promise that resolves to the exit code (0 for success, 1 for error)
  *
@@ -1031,111 +4299,470 @@ export declare class LocationDataModel extends AbstractLocationType {
 export declare function main(argv: string[]): Promise<number>;
 
 /**
+ * Concrete implementation for member elements within documentation.
+ *
+ * @remarks
+ * Provides specific handling for member XML elements that contain
+ * simplified member information within various documentation contexts.
+ * This implementation extends the abstract base class functionality
+ * to process member elements with the specific element name 'member'.
+ *
+ * The class represents lightweight member references that serve as
+ * cross-reference points to more detailed member definitions, maintaining
+ * essential identification data whilst enabling efficient navigation
+ * within the documentation system. These elements are commonly used
+ * in member lists and summary sections where full member details
+ * are not required.
+ *
  * @public
  */
 export declare class MemberDataModel extends AbstractMemberType {
+    /**
+     * Constructs a new member data model instance.
+     *
+     * @param xml - The XML parser instance for processing elements
+     * @param element - The source XML element containing member data
+     *
+     * @remarks
+     * Initialises the data model with the specific element name 'member'
+     * and delegates processing to the abstract base class implementation.
+     * This ensures consistent handling of simplified member information
+     * whilst maintaining proper element identification for cross-referencing
+     * and navigation functionality.
+     *
+     * @public
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Concrete implementation for memberdef elements within compound documentation.
+ *
+ * @remarks
+ * Provides specific handling for memberdef XML elements that contain
+ * comprehensive member definition information within classes, structures,
+ * namespaces, and other compound types. This implementation extends the
+ * abstract base class functionality to process the complete range of
+ * member definitions including functions, variables, typedefs, enums,
+ * and specialised language constructs.
+ *
+ * The class ensures proper instantiation of member definition data models
+ * whilst maintaining all the detailed metadata required for accurate
+ * documentation generation including cross-references, location information,
+ * and language-specific attributes.
+ *
  * @public
  */
 export declare class MemberDefDataModel extends AbstractMemberDefType {
+    /**
+     * Constructs a new memberdef data model instance.
+     *
+     * @param xml - The XML parser instance for processing elements
+     * @param element - The source XML element containing memberdef data
+     *
+     * @remarks
+     * Initialises the data model with the specific element name 'memberdef'
+     * and delegates processing to the abstract base class implementation.
+     * This ensures consistent handling of member definition information
+     * whilst maintaining proper element identification.
+     *
+     * @public
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Concrete implementation for member reference elements within documentation.
+ *
+ * @remarks
+ * Provides specific handling for member XML elements that contain
+ * comprehensive member reference information within class and compound
+ * documentation. This implementation extends the abstract base class
+ * functionality to process member references with the specific element
+ * name 'member'.
+ *
+ * The class ensures proper instantiation of member reference data models
+ * whilst maintaining all the cross-referencing metadata required for
+ * accurate documentation linking and navigation between related members
+ * within the documentation system.
+ *
  * @public
  */
 export declare class MemberRefDataModel extends AbstractMemberRefType {
+    /**
+     * Constructs a new member reference data model instance.
+     *
+     * @param xml - The XML parser instance for processing elements
+     * @param element - The source XML element containing member reference data
+     *
+     * @remarks
+     * Initialises the data model with the specific element name 'member'
+     * and delegates processing to the abstract base class implementation.
+     * This ensures consistent handling of member reference information
+     * whilst maintaining proper element identification for cross-referencing
+     * functionality.
+     *
+     * @public
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
- * Options, when multi-configurations are used.
+ * Multiple configuration sets for different build scenarios.
+ *
+ * @remarks
+ * Allows defining different configuration profiles that can be selected
+ * based on the build context or command line parameters.
  *
  * @public
  */
 declare type MultiConfigurations = Record<string, CliConfigurationOptions>;
 
 /**
+ * Concrete implementation for parameter elements within function documentation.
+ *
+ * @remarks
+ * Provides specific handling for param XML elements that contain
+ * comprehensive parameter information within function and method
+ * documentation. This implementation extends the abstract base class
+ * functionality to process parameter elements with the specific
+ * element name 'param'.
+ *
+ * The class ensures proper instantiation of parameter data models
+ * whilst maintaining all the detailed parameter metadata required
+ * for accurate function signature documentation including type
+ * information, naming variations, default values, constraints,
+ * and descriptive information.
+ *
  * @public
  */
 export declare class ParamDataModel extends AbstractParamType {
+    /**
+     * Constructs a new parameter data model instance.
+     *
+     * @param xml - The XML parser instance for processing elements
+     * @param element - The source XML element containing parameter data
+     *
+     * @remarks
+     * Initialises the data model with the specific element name 'param'
+     * and delegates processing to the abstract base class implementation.
+     * This ensures consistent handling of parameter information whilst
+     * maintaining proper element identification for function signature
+     * documentation and API reference generation.
+     *
+     * @public
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * 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 declare 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: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Data model for reference relationship elements.
+ *
+ * @remarks
+ * Represents a forward reference relationship within Doxygen XML
+ * documentation, corresponding to the references XML element. This class
+ * manages relationships where the current entity references or depends upon
+ * another documented entity. The relationship captures both the descriptive
+ * information and precise location data, enabling comprehensive dependency
+ * tracking and navigation capabilities. Forward references help document
+ * how entities use or depend on other components within the codebase.
+ *
  * @public
  */
 export declare class ReferenceDataModel extends AbstractReferenceType {
+    /**
+     * Constructs a new reference relationship data model from XML.
+     *
+     * @param xml - The Doxygen XML parser instance
+     * @param element - The XML element containing reference relationship data
+     *
+     * @remarks
+     * Creates a complete forward reference relationship data model by parsing
+     * the provided XML element. This constructor delegates to the parent class
+     * to handle all standard parsing operations for the references element type,
+     * establishing the forward dependency relationship between the current
+     * entity and the referenced component.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Data model for referenced-by relationship elements.
+ *
+ * @remarks
+ * Represents a reverse reference relationship within Doxygen XML
+ * documentation, corresponding to the referencedby XML element. This class
+ * manages relationships where the current entity is referenced or used by
+ * another documented entity. The relationship provides bidirectional
+ * dependency information, enabling comprehensive understanding of how
+ * entities are utilised throughout the codebase. Referenced-by relationships
+ * are essential for impact analysis and understanding the scope of changes
+ * when modifying documented components.
+ *
  * @public
  */
 export declare class ReferencedByDataModel extends AbstractReferenceType {
+    /**
+     * Constructs a new referenced-by relationship data model from XML.
+     *
+     * @param xml - The Doxygen XML parser instance
+     * @param element - The XML element containing referenced-by relationship data
+     *
+     * @remarks
+     * Creates a complete reverse reference relationship data model by parsing
+     * the provided XML element. This constructor delegates to the parent class
+     * to handle all standard parsing operations for the referencedby element
+     * type, establishing the reverse dependency relationship indicating how
+     * other entities utilise the current component.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Data model for reimplement relationship elements.
+ *
+ * @remarks
+ * Represents a specific reimplement relationship within Doxygen XML
+ * documentation, corresponding to the reimplements XML element. This class
+ * manages relationships where the current entity reimplements or overrides
+ * behaviour from a base class or interface. The relationship captures both
+ * the descriptive information and the reference to the original implementation,
+ * enabling comprehensive documentation of polymorphic behaviours and
+ * inheritance patterns within object-oriented codebases.
+ *
  * @public
  */
 export declare class ReimplementDataModel extends AbstractReimplementType {
+    /**
+     * Constructs a new reimplement relationship data model from XML.
+     *
+     * @param xml - The Doxygen XML parser instance
+     * @param element - The XML element containing reimplement relationship data
+     *
+     * @remarks
+     * Creates a complete reimplement relationship data model by parsing the
+     * provided XML element. This constructor delegates to the parent class to
+     * handle all standard parsing operations for the reimplements element type,
+     * establishing the relationship between the current entity and the
+     * reimplemented base implementation.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Concrete data model for section definition elements.
+ *
+ * @remarks
+ * Represents a specific section definition within Doxygen XML documentation,
+ * corresponding to the sectiondef XML element. This class provides the
+ * complete implementation for parsing and managing section definition data,
+ * including all supported attributes, elements, and member collections. Each
+ * instance represents a single section within a compound or group structure.
+ *
  * @public
  */
 export declare class SectionDefDataModel extends AbstractSectionDefType {
+    /**
+     * Constructs a new section definition data model from XML.
+     *
+     * @param xml - The Doxygen XML parser instance
+     * @param element - The XML element containing section definition data
+     *
+     * @remarks
+     * Creates a complete section definition data model by parsing the provided
+     * XML element. This constructor delegates to the parent class to handle all
+     * standard parsing operations for the sectiondef element type.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Concrete data model class for table of contents elements.
+ *
+ * @remarks
+ * Represents individual table of contents elements found within Doxygen
+ * compound XML structures. This class extends the abstract base to provide
+ * specific handling for 'tableofcontents' elements, which define the
+ * structural navigation and organisation of documentation content. Each
+ * table of contents provides hierarchical access to documentation sections
+ * and subsections.
+ *
  * @public
  */
 export declare class TableOfContentsDataModel extends AbstractTableOfContentsType {
+    /**
+     * Constructs a new TableOfContentsDataModel instance from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML elements
+     * @param element - The XML element containing the table of contents data
+     *
+     * @remarks
+     * Initialises the table of contents data model by parsing the provided
+     * XML element as a 'tableofcontents' element type. The constructor
+     * delegates to the parent class for common table of contents processing
+     * whilst specifying the element name for proper XML structure handling.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Concrete data model class for template parameter list elements.
+ *
+ * @remarks
+ * Represents individual template parameter list elements found within
+ * Doxygen compound XML structures. This class extends the abstract base
+ * to provide specific handling for 'templateparamlist' elements, which
+ * define the template parameters for templated constructs such as template
+ * classes, template functions, and template variables. Each template
+ * parameter list contains parameter definitions that specify the generic
+ * types and values used in template instantiation.
+ *
  * @public
  */
 export declare class TemplateParamListDataModel extends AbstractTemplateParamListType {
+    /**
+     * Constructs a new TemplateParamListDataModel instance from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML elements
+     * @param element - The XML element containing the template parameter list
+     * data
+     *
+     * @remarks
+     * Initialises the template parameter list data model by parsing the
+     * provided XML element as a 'templateparamlist' element type. The
+     * constructor delegates to the parent class for common parameter list
+     * processing whilst specifying the element name for proper XML structure
+     * handling.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Concrete data model class for table of contents section elements.
+ *
+ * @remarks
+ * Represents individual table of contents section elements found within
+ * Doxygen XML structures. This class extends the abstract base to provide
+ * specific handling for 'tocsect' elements, which define named sections
+ * within the table of contents hierarchy. Each section includes a name,
+ * reference, and potentially nested subsections for comprehensive
+ * documentation navigation.
+ *
  * @public
  */
 export declare class TocSectDataModel extends AbstractTableOfContentsKindType {
+    /**
+     * Constructs a new TocSectDataModel instance from XML data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML elements
+     * @param element - The XML element containing the table of contents section
+     * data
+     *
+     * @remarks
+     * Initialises the table of contents section data model by parsing the
+     * provided XML element as a 'tocsect' element type. The constructor
+     * delegates to the parent class for common section processing whilst
+     * specifying the element name for proper XML structure handling.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Data model for type constraint elements within documentation content.
+ *
+ * @remarks
+ * Represents type constraint elements that contain template and generic
+ * type constraint information within source code documentation. This
+ * implementation processes Doxygen's typeconstraint elements, which contain
+ * mixed text and reference content describing constraints applied to
+ * template parameters and generic types.
+ *
+ * The linked text structure enables cross-references to constraint types,
+ * concepts, and related template documentation within constraint expressions.
+ *
  * @public
  */
 export declare class TypeConstraintDataModel extends AbstractLinkedTextType {
+    /**
+     * Constructs a TypeConstraintDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the type constraint data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractLinkedTextType to
+     * handle linked text processing whilst identifying the element as
+     * 'typeconstraint' for proper XML schema compliance and type constraint
+     * content processing.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Data model for type elements within documentation content.
+ *
+ * @remarks
+ * Represents type elements that contain type information and declarations
+ * within source code documentation. This implementation processes Doxygen's
+ * type elements, which contain mixed text and reference content describing
+ * data types, including primitive types, class names, template parameters,
+ * and complex type expressions.
+ *
+ * The linked text structure enables cross-references to type definitions
+ * and related documentation within the type expressions.
+ *
  * @public
  */
 export declare class TypeDataModel extends AbstractLinkedTextType {
+    /**
+     * Constructs a TypeDataModel from XML element data.
+     *
+     * @param xml - The Doxygen XML parser instance for processing XML content
+     * @param element - The XML element object containing the type data
+     *
+     * @remarks
+     * This constructor delegates to the parent AbstractLinkedTextType to
+     * handle linked text processing whilst identifying the element as 'type'
+     * for proper XML schema compliance and type information content processing.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 
 /**
+ * Represents a generic XML element in the parsed structure.
+ *
+ * @remarks
+ * Defines the structure used by the XML parser for representing parsed
+ * XML elements, including text content, attributes, and child elements.
+ * Each element maps keys to arrays of child elements.
+ *
  * @public
  */
 export declare interface XmlElement {