@xpack/doxygen2docusaurus 1.0.2 → 2.0.0

package/dist/doxygen/data-model/compounds/reimplementtype-dm.d.ts

@@ -1,20 +1,119 @@
 import { DoxygenXmlParser } from '../doxygen-xml-parser.js';
 import { AbstractDataModelBase } from '../types.js';
 /**
+ * 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);
 }
 /**
+ * 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);
 }
+/**
+ * Data model for reimplemented-by relationship elements.
+ *
+ * @remarks
+ * Represents the inverse reimplement relationship within Doxygen XML
+ * documentation, corresponding to the reimplementedby XML element. This class
+ * manages relationships where the current entity is reimplemented or overridden
+ * by derived classes or implementing types. The relationship provides a
+ * reverse-lookup capability, allowing documentation of which entities override
+ * or reimplement the current method or function. This bidirectional
+ * relationship documentation enables comprehensive understanding of inheritance
+ * hierarchies and polymorphic implementations.
+ *
+ * @public
+ */
 export declare class ReimplementedByDataModel extends AbstractReimplementType {
+    /**
+     * Constructs a new reimplemented-by relationship data model from XML.
+     *
+     * @param xml - The Doxygen XML parser instance
+     * @param element - The XML element containing reimplemented-by relationship
+     *   data
+     *
+     * @remarks
+     * Creates a complete reimplemented-by relationship data model by parsing the
+     * provided XML element. This constructor delegates to the parent class to
+     * handle all standard parsing operations for the reimplementedby element
+     * type, establishing the reverse relationship between the current entity
+     * and the implementing derived classes or types.
+     */
     constructor(xml: DoxygenXmlParser, element: object);
 }
 //# sourceMappingURL=reimplementtype-dm.d.ts.map

package/dist/doxygen/data-model/compounds/reimplementtype-dm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reimplementtype-dm.d.ts","sourceRoot":"","sources":["../../../../src/doxygen/data-model/compounds/reimplementtype-dm.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAYnD;;GAEG;AACH,8BAAsB,uBAAwB,SAAQ,qBAAqB;IAEzE,IAAI,SAAK;IAGT,KAAK,SAAK;gBAEE,GAAG,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;CAwCxE;AAOD;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,uBAAuB;gBACnD,GAAG,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM;CAInD;AAED,qBAAa,wBAAyB,SAAQ,uBAAuB;gBACvD,GAAG,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM;CAInD"}
+{"version":3,"file":"reimplementtype-dm.d.ts","sourceRoot":"","sources":["../../../../src/doxygen/data-model/compounds/reimplementtype-dm.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAYnD;;;;;;;;;;;;;;GAcG;AACH,8BAAsB,uBAAwB,SAAQ,qBAAqB;IACzE;;;;;;;;OAQG;IACH,IAAI,SAAK;IAET;;;;;;;;;OASG;IACH,KAAK,SAAK;IAEV;;;;;;;;;;;;;;OAcG;gBACS,GAAG,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;CAwCxE;AAOD;;;;;;;;;;;;;GAaG;AACH,qBAAa,oBAAqB,SAAQ,uBAAuB;IAC/D;;;;;;;;;;;;OAYG;gBACS,GAAG,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM;CAInD;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,wBAAyB,SAAQ,uBAAuB;IACnE;;;;;;;;;;;;;OAaG;gBACS,GAAG,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM;CAInD"}

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

@@ -21,13 +21,57 @@ import { AbstractDataModelBase } from '../types.js';
 //   </xsd:simpleContent>
 // </xsd:complexType>
 /**
+ * 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 class AbstractReimplementType extends AbstractDataModelBase {
-    // Mandatory elements.
+    /**
+     * 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 = ''; // Passed as element text.
-    // Mandatory attributes.
+    /**
+     * 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 = '';
+    /**
+     * 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, element, elementName) {
         super(elementName);
         // console.log(elementName, util.inspect(element,
@@ -59,15 +103,68 @@ export class AbstractReimplementType extends AbstractDataModelBase {
 //     <xsd:element name="reimplements" type="reimplementType" minOccurs="0" maxOccurs="unbounded" />
 //     <xsd:element name="reimplementedby" type="reimplementType" minOccurs="0" maxOccurs="unbounded" />
 /**
+ * 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 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, element) {
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
         super(xml, element, 'reimplements');
     }
 }
+/**
+ * Data model for reimplemented-by relationship elements.
+ *
+ * @remarks
+ * Represents the inverse reimplement relationship within Doxygen XML
+ * documentation, corresponding to the reimplementedby XML element. This class
+ * manages relationships where the current entity is reimplemented or overridden
+ * by derived classes or implementing types. The relationship provides a
+ * reverse-lookup capability, allowing documentation of which entities override
+ * or reimplement the current method or function. This bidirectional
+ * relationship documentation enables comprehensive understanding of inheritance
+ * hierarchies and polymorphic implementations.
+ *
+ * @public
+ */
 export class ReimplementedByDataModel extends AbstractReimplementType {
+    /**
+     * Constructs a new reimplemented-by relationship data model from XML.
+     *
+     * @param xml - The Doxygen XML parser instance
+     * @param element - The XML element containing reimplemented-by relationship
+     *   data
+     *
+     * @remarks
+     * Creates a complete reimplemented-by relationship data model by parsing the
+     * provided XML element. This constructor delegates to the parent class to
+     * handle all standard parsing operations for the reimplementedby element
+     * type, establishing the reverse relationship between the current entity
+     * and the implementing derived classes or types.
+     */
     constructor(xml, element) {
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
         super(xml, element, 'reimplementedby');

package/dist/doxygen/data-model/compounds/reimplementtype-dm.js.map

@@ -1 +1 @@
-{"version":3,"file":"reimplementtype-dm.js","sourceRoot":"","sources":["../../../../src/doxygen/data-model/compounds/reimplementtype-dm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,+EAA+E;AAE/E,OAAO,MAAM,MAAM,aAAa,CAAA;AAChC,OAAO,IAAI,MAAM,WAAW,CAAA;AAG5B,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAEnD,+EAA+E;AAE/E,2CAA2C;AAC3C,wBAAwB;AACxB,wCAAwC;AACxC,yDAAyD;AACzD,uBAAuB;AACvB,yBAAyB;AACzB,qBAAqB;AAErB;;GAEG;AACH,MAAM,OAAgB,uBAAwB,SAAQ,qBAAqB;IACzE,sBAAsB;IACtB,IAAI,GAAG,EAAE,CAAA,CAAC,0BAA0B;IAEpC,wBAAwB;IACxB,KAAK,GAAG,EAAE,CAAA;IAEV,YAAY,GAAqB,EAAE,OAAe,EAAE,WAAmB;QACrE,KAAK,CAAC,WAAW,CAAC,CAAA;QAElB,iDAAiD;QACjD,qCAAqC;QAErC,2EAA2E;QAC3E,oBAAoB;QAEpB,MAAM,CAAC,GAAG,CAAC,kBAAkB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAA;QACpD,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,mBAAmB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAA;QAEzD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;QAE5B,2EAA2E;QAC3E,sBAAsB;QAEtB,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAA;QAElC,MAAM,eAAe,GAAG,GAAG,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAA;QACvD,KAAK,MAAM,aAAa,IAAI,eAAe,EAAE,CAAC;YAC5C,IAAI,aAAa,KAAK,SAAS,EAAE,CAAC;gBAChC,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,uBAAuB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAA;YAC9D,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,CAAA;gBACpE,OAAO,CAAC,KAAK,CACX,GAAG,WAAW,aAAa,EAC3B,aAAa,EACb,wBAAwB,EACxB,IAAI,CAAC,WAAW,CAAC,IAAI,CACtB,CAAA;YACH,CAAC;QACH,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;QAE7B,2EAA2E;QAE3E,kEAAkE;IACpE,CAAC;CACF;AAED,+EAA+E;AAE/E,qGAAqG;AACrG,wGAAwG;AAExG;;GAEG;AACH,MAAM,OAAO,oBAAqB,SAAQ,uBAAuB;IAC/D,YAAY,GAAqB,EAAE,OAAe;QAChD,kFAAkF;QAClF,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,cAAc,CAAC,CAAA;IACrC,CAAC;CACF;AAED,MAAM,OAAO,wBAAyB,SAAQ,uBAAuB;IACnE,YAAY,GAAqB,EAAE,OAAe;QAChD,kFAAkF;QAClF,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,iBAAiB,CAAC,CAAA;IACxC,CAAC;CACF;AAED,+EAA+E"}
+{"version":3,"file":"reimplementtype-dm.js","sourceRoot":"","sources":["../../../../src/doxygen/data-model/compounds/reimplementtype-dm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,+EAA+E;AAE/E,OAAO,MAAM,MAAM,aAAa,CAAA;AAChC,OAAO,IAAI,MAAM,WAAW,CAAA;AAG5B,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAEnD,+EAA+E;AAE/E,2CAA2C;AAC3C,wBAAwB;AACxB,wCAAwC;AACxC,yDAAyD;AACzD,uBAAuB;AACvB,yBAAyB;AACzB,qBAAqB;AAErB;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAgB,uBAAwB,SAAQ,qBAAqB;IACzE;;;;;;;;OAQG;IACH,IAAI,GAAG,EAAE,CAAA,CAAC,0BAA0B;IAEpC;;;;;;;;;OASG;IACH,KAAK,GAAG,EAAE,CAAA;IAEV;;;;;;;;;;;;;;OAcG;IACH,YAAY,GAAqB,EAAE,OAAe,EAAE,WAAmB;QACrE,KAAK,CAAC,WAAW,CAAC,CAAA;QAElB,iDAAiD;QACjD,qCAAqC;QAErC,2EAA2E;QAC3E,oBAAoB;QAEpB,MAAM,CAAC,GAAG,CAAC,kBAAkB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAA;QACpD,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,mBAAmB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAA;QAEzD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;QAE5B,2EAA2E;QAC3E,sBAAsB;QAEtB,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAA;QAElC,MAAM,eAAe,GAAG,GAAG,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAA;QACvD,KAAK,MAAM,aAAa,IAAI,eAAe,EAAE,CAAC;YAC5C,IAAI,aAAa,KAAK,SAAS,EAAE,CAAC;gBAChC,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,uBAAuB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAA;YAC9D,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,CAAA;gBACpE,OAAO,CAAC,KAAK,CACX,GAAG,WAAW,aAAa,EAC3B,aAAa,EACb,wBAAwB,EACxB,IAAI,CAAC,WAAW,CAAC,IAAI,CACtB,CAAA;YACH,CAAC;QACH,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;QAE7B,2EAA2E;QAE3E,kEAAkE;IACpE,CAAC;CACF;AAED,+EAA+E;AAE/E,qGAAqG;AACrG,wGAAwG;AAExG;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,oBAAqB,SAAQ,uBAAuB;IAC/D;;;;;;;;;;;;OAYG;IACH,YAAY,GAAqB,EAAE,OAAe;QAChD,kFAAkF;QAClF,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,cAAc,CAAC,CAAA;IACrC,CAAC;CACF;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,wBAAyB,SAAQ,uBAAuB;IACnE;;;;;;;;;;;;;OAaG;IACH,YAAY,GAAqB,EAAE,OAAe;QAChD,kFAAkF;QAClF,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,iBAAiB,CAAC,CAAA;IACxC,CAAC;CACF;AAED,+EAA+E"}

package/dist/doxygen/data-model/compounds/sectiondeftype-dm.d.ts

@@ -4,31 +4,190 @@ import { MemberDefDataModel } from './memberdeftype-dm.js';
 import { MemberDataModel } from './membertype-dm.js';
 import { AbstractDataModelBase } from '../types.js';
 /**
+ * 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 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);
 }
 /**
+ * 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);
 }
+/**
+ * Data model for section definitions organised by kind classification.
+ *
+ * @remarks
+ * Represents a section definition that is categorised by a specific kind
+ * without requiring XML parsing. This class is useful for creating organised
+ * collections of section definitions based on their classification types,
+ * allowing for structured presentation and filtering of documentation sections.
+ * The kind-based organisation enables efficient grouping and processing of
+ * related sections within the documentation structure.
+ *
+ * @public
+ */
 export declare class SectionDefByKindDataModel extends AbstractSectionDefTypeBase {
+    /**
+     * Constructs a new section definition organised by kind.
+     *
+     * @param kind - The section kind classification
+     *
+     * @remarks
+     * Creates a section definition data model with the specified kind
+     * classification. This constructor is used when creating organised
+     * collections of sections based on their type, without requiring
+     * XML parsing operations.
+     */
     constructor(kind: string);
 }
 //# sourceMappingURL=sectiondeftype-dm.d.ts.map

package/dist/doxygen/data-model/compounds/sectiondeftype-dm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sectiondeftype-dm.d.ts","sourceRoot":"","sources":["../../../../src/doxygen/data-model/compounds/sectiondeftype-dm.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAgBnD;;GAEG;AACH,8BAAsB,0BAA2B,SAAQ,qBAAqB;IAE5E,IAAI,SAAK;IAGT,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,WAAW,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAA;IAG9C,UAAU,CAAC,EAAE,kBAAkB,EAAE,GAAG,SAAS,CAAA;IAC7C,OAAO,CAAC,EAAE,eAAe,EAAE,GAAG,SAAS,CAAA;gBAE3B,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAM7C,UAAU,IAAI,OAAO;IAIrB,mBAAmB,CACjB,aAAa,EAAE,MAAM,EACrB,YAAY,GAAE,MAAsB,GACnC,MAAM;CAeV;AAED;;GAEG;AAEH,8BAAsB,sBAAuB,SAAQ,0BAA0B;gBACjE,GAAG,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;CAgExE;AAMD;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,sBAAsB;gBACjD,GAAG,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM;CAInD;AAED,qBAAa,yBAA0B,SAAQ,0BAA0B;gBAC3D,IAAI,EAAE,MAAM;CAGzB"}
+{"version":3,"file":"sectiondeftype-dm.d.ts","sourceRoot":"","sources":["../../../../src/doxygen/data-model/compounds/sectiondeftype-dm.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAgBnD;;;;;;;;;;;;;GAaG;AACH,8BAAsB,0BAA2B,SAAQ,qBAAqB;IAC5E;;;;;;;OAOG;IACH,IAAI,SAAK;IAET;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAE3B;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAA;IAE9C;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,kBAAkB,EAAE,GAAG,SAAS,CAAA;IAE7C;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,eAAe,EAAE,GAAG,SAAS,CAAA;IAEvC;;;;;;;;;;OAUG;gBACS,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAM7C;;;;;;;;;;OAUG;IACH,UAAU,IAAI,OAAO;IAIrB;;;;;;;;;;;;;;OAcG;IACH,mBAAmB,CACjB,aAAa,EAAE,MAAM,EACrB,YAAY,GAAE,MAAsB,GACnC,MAAM;CAeV;AAED;;;;;;;;;;;;GAYG;AAEH,8BAAsB,sBAAuB,SAAQ,0BAA0B;IAC7E;;;;;;;;;;;;;;OAcG;gBACS,GAAG,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;CAgExE;AAMD;;;;;;;;;;;GAWG;AACH,qBAAa,mBAAoB,SAAQ,sBAAsB;IAC7D;;;;;;;;;;OAUG;gBACS,GAAG,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM;CAInD;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,yBAA0B,SAAQ,0BAA0B;IACvE;;;;;;;;;;OAUG;gBACS,IAAI,EAAE,MAAM;CAGzB"}

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

@@ -28,24 +28,111 @@ import { AbstractDataModelBase } from '../types.js';
 //   <xsd:attribute name="kind" type="DoxSectionKind" />
 // </xsd:complexType>
 /**
+ * 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 class AbstractSectionDefTypeBase extends AbstractDataModelBase {
-    // Mandatory attributes.
+    /**
+     * 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 = '';
-    // Optional elements.
+    /**
+     * 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;
+    /**
+     * 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;
-    // Actually only one is defined at a time.
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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, kind) {
         super(elementName);
         this.kind = kind;
     }
+    /**
+     * 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() {
         return this.memberDefs !== undefined || this.members !== undefined;
     }
+    /**
+     * 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, memberSuffix = sectionSuffix) {
         // Turn `public-func` into
         // - `public-constructor`
@@ -64,10 +151,35 @@ export class AbstractSectionDefTypeBase extends AbstractDataModelBase {
     }
 }
 /**
+ * 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
  */
 // eslint-disable-next-line max-len
 export 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, element, elementName) {
         super(elementName, '');
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
@@ -122,15 +234,59 @@ export class AbstractSectionDefType extends AbstractSectionDefTypeBase {
 // ----------------------------------------------------------------------------
 // <xsd:element name="sectiondef" type="sectiondefType" minOccurs="0" maxOccurs="unbounded" />
 /**
+ * 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 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, element) {
         // console.log(elementName, util.inspect(element, { compact: false, depth: 999 }))
         super(xml, element, 'sectiondef');
     }
 }
+/**
+ * Data model for section definitions organised by kind classification.
+ *
+ * @remarks
+ * Represents a section definition that is categorised by a specific kind
+ * without requiring XML parsing. This class is useful for creating organised
+ * collections of section definitions based on their classification types,
+ * allowing for structured presentation and filtering of documentation sections.
+ * The kind-based organisation enables efficient grouping and processing of
+ * related sections within the documentation structure.
+ *
+ * @public
+ */
 export class SectionDefByKindDataModel extends AbstractSectionDefTypeBase {
+    /**
+     * Constructs a new section definition organised by kind.
+     *
+     * @param kind - The section kind classification
+     *
+     * @remarks
+     * Creates a section definition data model with the specified kind
+     * classification. This constructor is used when creating organised
+     * collections of sections based on their type, without requiring
+     * XML parsing operations.
+     */
     constructor(kind) {
         super('sectiondef', kind);
     }