@xpack/doxygen2docusaurus 2.0.0 → 2.1.0

package/dist/doxygen2docusaurus.d.ts

@@ -1,4774 +0,0 @@
-/**
- * A CLI application to convert Doxygen XML files into Docusaurus
- * documentation.
- *
- * @remarks
- * This tool facilitates the integration of Doxygen reference pages into
- * Docusaurus documentation sites. It parses Doxygen-generated XML files and
- * produces Docusaurus `.md` documents, along with the corresponding sidebars
- * and menu entries.
- *
- * @packageDocumentation
- */
-
-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;
-    /**
-     * 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);
-}
-
-/**
- * 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>;
-
-/**
- * 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 {
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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'
-     */
-    navbarPosition: 'left' | 'right';
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * Note about the location of original Doxygen pages.
-     *
-     * @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 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 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;
-    /**
-     * 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
-     * model.
-     *
-     * @remarks
-     * This method reads and parses the `index.xml` file, ignoring the XML
-     * prologue and top-level text nodes. It extracts the `doxygenindex`
-     * element and constructs the corresponding data model. Any unrecognised
-     * elements are logged for diagnostic purposes.
-     */
-    parseDoxygenIndex(): Promise<void>;
-    /**
-     * Processes compound definitions from the parsed Doxygen XML elements.
-     *
-     * @param indexCompound - The compound index data model
-     * @param parsedDoxygenElements - The array of parsed XML elements for the
-     * compound
-     *
-     * @remarks
-     * This method iterates through the parsed XML elements, ignoring the XML
-     * prologue and top-level text nodes. For recognised `doxygen` elements, it
-     * constructs the compound definitions and appends them to the internal data
-     * model. Unrecognised elements are logged for further analysis.
-     */
-    processCompoundDefs(indexCompound: IndexCompoundDataModel, parsedDoxygenElements: XmlElement[]): void;
-    /**
-     * Processes member definitions and updates member kinds where necessary.
-     *
-     * @remarks
-     * This method traverses all compound definitions and their associated
-     * sections. It collects member definitions by their identifiers and, for
-     * each member with an empty kind, assigns the kind from the corresponding
-     * member definition. This ensures that all members are correctly classified
-     * within the internal data model.
-     */
-    processMemberdefs(): void;
-    /**
-     * Parses the Doxyfile XML and initialises the configuration data model.
-     *
-     * @remarks
-     * This method reads and parses the `Doxyfile.xml` file, ignoring the XML
-     * prologue and top-level text nodes. It extracts the `doxyfile` element and
-     * constructs the corresponding configuration data model. Any unrecognised
-     * elements are logged for diagnostic purposes.
-     */
-    parseDoxyfile(): Promise<void>;
-    /**
-     * Reads and parses the specified XML file, returning the parsed content.
-     *
-     * @param fileName - The name of the XML file to be parsed
-     * @returns A promise that resolves to the parsed XML content
-     *
-     * @remarks
-     * This method constructs the full file path using the configured input
-     * folder, reads the XML file as a UTF-8 string, and parses it using the
-     * configured XML parser. The method increments the internal counter for
-     * parsed files and, if verbose mode is enabled, logs the file being parsed.
-     */
-    parseFile({ fileName }: {
-        fileName: string;
-    }): Promise<any>;
-}
-
-/**
- * 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);
-}
-
-/**
- * XML parser for Doxygen-generated documentation files.
- *
- * @remarks
- * This class initialises the XML parser with options that preserve the order
- * and structure of the original XML content, ensuring accurate conversion
- * 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 });
- * const dataModel = await parser.parse();
- * ```
- *
- * @public
- */
-export declare class DoxygenXmlParser {
-    /**
-     * 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 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.
-     *
-     * @param options - The global configuration options
-     *
-     * @remarks
-     * 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.
-     */
-    constructor(options: CliOptions);
-    /**
-     * Determines whether the specified XML element has any attributes.
-     *
-     * @param element - The XML element to inspect for attributes
-     * @returns True if the element has attributes; otherwise, false
-     *
-     * @remarks
-     * This method checks for the presence of the ':\@' property on the XML
-     * element, which is the convention used by the XML parser for storing
-     * attributes. If this property exists, the element has attributes; if not,
-     * the element has no attributes. This is a prerequisite check before calling
-     * {@link DoxygenXmlParser.getAttributesNames} or other attribute-related
-     * methods.
-     */
-    hasAttributes(element: object): boolean;
-    /**
-     * Retrieves the names of all attributes present on the specified XML element.
-     *
-     * @param element - The XML element to inspect for attribute names
-     * @returns An array of strings containing the names of all attributes
-     *
-     * @remarks
-     * This method accesses the ':\@' property of the XML element, which is the
-     * convention used by the XML parser for storing attributes, and returns the
-     * keys of this object as an array of attribute names. The method assumes the
-     * element has attributes and does not perform validation - use
-     * {@link DoxygenXmlParser.hasAttributes} to check for attribute presence
-     * first.
-     */
-    getAttributesNames(element: object): string[];
-    /**
-     * Determines whether the specified attribute exists on the given XML element.
-     *
-     * @param element - The XML element to inspect
-     * @param name - The name of the attribute to check for
-     * @returns True if the attribute exists; otherwise, false
-     *
-     * @remarks
-     * This method checks for the presence of an attribute within the ':\@'
-     * property of the XML element, which is the convention used by the XML
-     * parser for storing attributes. It returns true if the attribute is found,
-     * otherwise false.
-     */
-    hasAttribute(element: object, name: string): boolean;
-    /**
-     * Retrieves the value of a named attribute as a string.
-     *
-     * @param element - The XML element containing the attribute
-     * @param name - The name of the attribute to retrieve
-     * @returns The attribute value as a string
-     * @throws If the attribute does not exist
-     *
-     * @remarks
-     * This method checks whether the specified attribute exists on the XML
-     * element and returns its value as a string. If the attribute value is
-     * originally a number (as the XML parser may return numeric strings as
-     * numbers), it is converted to a string to maintain consistency with the
-     * DTD specification. If the attribute is missing, an error is thrown to
-     * indicate the absence.
-     */
-    getAttributeStringValue(element: object, name: string): string;
-    /**
-     * Retrieves the value of a named attribute as a number.
-     *
-     * @param element - The XML element containing the attribute
-     * @param name - The name of the attribute to retrieve
-     * @returns The attribute value as a number
-     * @throws If the attribute does not exist or is not a number
-     *
-     * @remarks
-     * This method checks whether the specified attribute exists on the XML
-     * element and returns its value as a number. If the attribute is missing
-     * or its value is not a number, an error is thrown to indicate the absence
-     * or incorrect type.
-     */
-    getAttributeNumberValue(element: object, name: string): number;
-    /**
-     * Retrieves the value of a named attribute as a boolean.
-     *
-     * @param element - The XML element containing the attribute
-     * @param name - The name of the attribute to retrieve
-     * @returns True if the attribute value is 'yes' (case-insensitive);
-     * otherwise, false
-     * @throws If the attribute does not exist or is not a string
-     *
-     * @remarks
-     * This method checks whether the specified attribute exists on the XML
-     * element, and returns true if its value is the string 'yes'
-     * (case-insensitive). If the attribute is missing or its value is not a
-     * string, an error is thrown.
-     */
-    getAttributeBooleanValue(element: object, name: string): boolean;
-    /**
-     * Determines whether the specified inner element exists on the given XML
-     * element.
-     *
-     * @param element - The XML element to inspect
-     * @param name - The name of the inner element to check for
-     * @returns True if the inner element exists; otherwise, false
-     *
-     * @remarks
-     * This method checks for the presence of a named property on the XML element.
-     * For text nodes ('#text'), it verifies the value is a string, number, or
-     * boolean. For other elements, it confirms the property is an array, as
-     * per the XML parser's convention.
-     */
-    hasInnerElement(element: object, name: string): boolean;
-    /**
-     * Determines whether a named inner element contains text.
-     *
-     * @param element - The XML element to inspect
-     * @param name - The name of the inner element
-     * @returns True if the inner element contains text or is empty;
-     * otherwise, false
-     *
-     * @remarks
-     * This method checks if the specified inner element exists and contains a
-     * single text node, or is an empty array (representing an empty string).
-     * It asserts the expected structure and type of the value for robustness.
-     */
-    isInnerElementText(element: object, name: string): boolean;
-    /**
-     * Determines whether the XML element contains a text node.
-     *
-     * @param element - The XML element to inspect
-     * @returns True if the element contains a text node; otherwise, false
-     *
-     * @remarks
-     * This method checks for the presence of a '#text' property on the XML
-     * element, and verifies that its value is a string, number, or boolean.
-     */
-    hasInnerText(element: object): boolean;
-    /**
-     * Retrieves an array of named child elements from the given XML element.
-     *
-     * @typeParam T - The expected type of the child elements array
-     * (defaults to XmlElement[])
-     * @param element - The XML element containing the child elements
-     * @param name - The name of the child elements to retrieve
-     * @returns The array of child elements
-     * @throws If the child elements do not exist
-     *
-     * @remarks
-     * This method accesses the specified property on the XML element and
-     * returns it as an array of child elements. If the property is undefined,
-     * an error is thrown indicating the absence of the expected child element.
-     */
-    getInnerElements<T = XmlElement[]>(element: object, name: string): T;
-    /**
-     * Retrieves the text content of a named child element.
-     *
-     * @param element - The XML element containing the child element
-     * @param name - The name of the child element
-     * @returns The text content of the child element
-     * @throws If the child element does not exist or contains more than one
-     * element
-     *
-     * @remarks
-     * This method accesses the specified child element and returns its text
-     * content. If the child element is missing, an error is thrown. If the
-     * child element is empty, an empty string is returned. If there is more
-     * than one child element, an error is thrown to indicate unexpected
-     * structure.
-     */
-    getInnerElementText(element: object, name: string): string;
-    /**
-     * Retrieves the numeric value of a named child element.
-     *
-     * @param element - The XML element containing the child element
-     * @param name - The name of the child element
-     * @returns The numeric value of the child element
-     * @throws If the child element does not exist or contains more than one
-     * element
-     *
-     * @remarks
-     * This method accesses the specified child element and returns its value
-     * as a number. If the child element is missing, an error is thrown. If the
-     * child element is empty, NaN is returned. If there is more than one child
-     * element, an error is thrown to indicate unexpected structure.
-     */
-    getInnerElementNumber(element: object, name: string): number;
-    /**
-     * Retrieves the boolean value of a named child element.
-     *
-     * @param element - The XML element containing the child element
-     * @param name - The name of the child element
-     * @returns True if the child element's text is 'true'
-     * (case-insensitive); otherwise, false
-     * @throws If the child element does not exist or contains more than one
-     * element
-     *
-     * @remarks
-     * This method accesses the specified child element and returns its value
-     * as a boolean. If the child element is missing, an error is thrown. If
-     * the child element is empty, false is returned. If there is more than one
-     * child element, an error is thrown to indicate unexpected structure.
-     */
-    getInnerElementBoolean(element: object, name: string): boolean;
-    /**
-     * Retrieves the text content of the XML element.
-     *
-     * @param element - The XML element to retrieve text from
-     * @returns The text content of the element
-     * @throws If the element does not contain a valid text node
-     *
-     * @remarks
-     * This method accesses the '#text' property of the XML element and
-     * returns its value as a string. It asserts that the value is of type
-     * string, number, or boolean before converting it to a string. If the
-     * property is missing or the value is of an unexpected type, an error is
-     * thrown.
-     */
-    getInnerText(element: object): string;
-}
-
-/**
- * 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)
- *
- * @public
- */
-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);
-}
-
-/**
- * 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 {
-    (key: string): XmlElement[];
-    '#text': string | number | boolean;
-    ':@'?: Record<string, string | number | boolean>;
-}
-
-export { }