@odx/angular 6.0.0 → 6.1.0

package/components/footer/lib/footer.component.d.ts

@@ -5,18 +5,21 @@ import * as i0 from "@angular/core";
 /**
  * Represents the footer component of an application, dynamically generating links and supporting various styles.
  * This component integrates dynamic and static content for the footer, including a logo, navigational links, and a customizable description.
- *
- * @usage `<odx-footer [description]="dynamicOrStaticContent" [variant]="'light'|'dark'"></odx-footer>`
- *
- * @input
- * - `description` - Accepts dynamic content (observable or static string) for displaying a custom description in the footer.
- * - `variant` - Sets the footer's appearance theme, supporting `light` and `dark` variants as defined by `FooterVariant`.
  */
 export declare class FooterComponent {
     protected readonly footerLinks$: import("rxjs").Observable<import("./models").FooterLink[]>;
     protected readonly trackByIndex: typeof trackByIndex;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * The description of the footer component.
+     * It can be of type DynamicTextContent or null.
+     * @see {DynamicTextContent}
+     */
     description?: DynamicTextContent | null;
+    /**
+     * The variant of the footer component.
+     * @see {FooterVariant}
+     */
     variant: FooterVariant;
     static ɵfac: i0.ɵɵFactoryDeclaration<FooterComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FooterComponent, "odx-footer", never, { "description": { "alias": "description"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, never, ["*", "[odxLink]"], true, never>;

package/components/footer/lib/footer.config.d.ts

@@ -15,6 +15,7 @@ export interface FooterLinksConfig extends MainMenuLinksConfig {
  * - `provideFooterLinksConfig`: A function to provide a custom configuration for footer links.
  *
  * @example
+ * ```ts
  * // In your module or component
  * @NgModule({
  *   providers: [
@@ -26,5 +27,6 @@ export interface FooterLinksConfig extends MainMenuLinksConfig {
  *   ]
  * })
  * export class MyModule {}
+ * ```
  */
 export declare const FooterLinksConfig: import("@angular/core").InjectionToken<Partial<FooterLinksConfig>>, FooterLinksDefaultConfig: FooterLinksConfig, injectFooterLinksConfig: () => FooterLinksConfig, provideFooterLinksConfig: <D extends import("@odx/angular/utils").ConfigDependencies<unknown> = import("@odx/angular/utils").ConfigDependencies<Partial<FooterLinksConfig>>>(config: import("@odx/angular/utils").ConfigProvider<Partial<FooterLinksConfig>, D>) => import("@angular/core").FactoryProvider | import("@angular/core").ValueProvider;

package/components/form-field/lib/components/form-field-info/form-field-info.component.d.ts

@@ -1,8 +1,21 @@
 import { FormFieldService } from '../../form-field.service';
 import { FormFieldError } from '../../models';
 import * as i0 from "@angular/core";
+/**
+ * A component that displays form field information such as hints or error messages, providing feedback to the user.
+ * It integrates with the `FormFieldService` to reactively update and display this information based on the state of a
+ * form field. The component uses dynamic content loading to facilitate the rendering of custom template-driven or
+ * reactive hints and error messages, enhancing the flexibility and reusability of form validations and user prompts.
+ */
 export declare class FormFieldInfoComponent {
     protected readonly formFieldService: FormFieldService;
+    /**
+     * Input property that takes a `FormFieldError` object. This object contains detailed information about
+     * the form field error state including the message to be displayed, the key identifier of the error, and
+     * any contextual data that might be necessary for error resolution.
+     *
+     * @see {FormFieldError}
+     */
     error: FormFieldError | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldInfoComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldInfoComponent, "odx-form-field-info", never, { "error": { "alias": "error"; "required": false; }; }, {}, never, ["*"], true, never>;

package/components/form-field/lib/components/form-group/form-group.component.d.ts

@@ -3,9 +3,25 @@ import { Observable } from 'rxjs';
 import { FormFieldError } from '../../models';
 import { FormFieldErrorService } from '../../services';
 import * as i0 from "@angular/core";
+/**
+ * A component that aggregates multiple form field error services to manage and display error states across
+ * a group of form fields. It facilitates centralized error handling and dynamic updates to error messages,
+ * making it ideal for forms with complex validation rules or multiple data entry points.
+ *
+ * This component dynamically listens to changes in error states from its child components and updates the
+ * error information displayed to the user based on the most relevant error.
+ */
 export declare class FormGroupComponent implements AfterContentInit {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * An observable that emits the current error state of the form group. It is calculated by combining the error states
+     * of all child form fields and selecting the most relevant error to display.
+     */
     error$: Observable<FormFieldError | null> | null;
+    /**
+     * A QueryList containing all instances of FormFieldErrorService used by child components of this form group. This list
+     * is used to subscribe to error changes in all child components and dynamically update the group's error state.
+     */
     formFieldErrorServices: QueryList<FormFieldErrorService>;
     ngAfterContentInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FormGroupComponent, never>;

package/components/form-field/lib/directives/form-field-control.directive.d.ts

@@ -1,5 +1,10 @@
 import { OnDestroy, OnInit } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Represents a directive that provides control functionality for a form field.
+ * This directive is responsible for registering the control with the form field service,
+ * handling control changes, and managing form field attributes and error states.
+ */
 export declare class FormFieldControlDirective implements OnInit, OnDestroy {
     private readonly ngControl;
     private readonly form;

package/components/form-field/lib/directives/form-field-error.directive.d.ts

@@ -1,8 +1,14 @@
 import { OnInit } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Directive for displaying custom error messages in a form field.
+ */
 export declare class FormFieldErrorDirective implements OnInit {
     private readonly formFieldErrorService;
     private readonly template;
+    /**
+     * The key used to identify the custom error message.
+     */
     key?: string;
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldErrorDirective, never>;

package/components/form-field/lib/directives/form-field-hint.directive.d.ts

@@ -1,5 +1,8 @@
 import { FormFieldService } from '../form-field.service';
 import * as i0 from "@angular/core";
+/**
+ * Directive for displaying a hint within a form field.
+ */
 export declare class FormFieldHintDirective {
     protected readonly formFieldService: FormFieldService;
     constructor();

package/components/form-field/lib/directives/form-field-label.directive.d.ts

@@ -1,4 +1,7 @@
 import * as i0 from "@angular/core";
+/**
+ * Directive for the label element within a form field.
+ */
 export declare class FormFieldLabelDirective {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldLabelDirective, never>;

package/components/form-field/lib/directives/form.directive.d.ts

@@ -1,7 +1,20 @@
 import * as i0 from "@angular/core";
+/**
+ * Represents a directive for handling form-related functionality.
+ * This directive listens for form submit and reset events, making them observable, which can be used to handle
+ * form interactions more reactively within Angular applications.
+ */
 export declare class FormDirective {
     readonly element: import("@angular/core").ElementRef<HTMLFormElement>;
+    /**
+     * An Observable that emits events every time the form is submitted. This stream is shared among multiple subscribers,
+     * which means the form's submit event is processed as it occurs and is multicasted to all subscribers.
+     */
     readonly submit$: import("rxjs").Observable<Event>;
+    /**
+     * An Observable that emits events every time the form is reset. Similar to `submit$`, this stream is also shared
+     * among multiple subscribers, allowing components to react to form resets reactively and concurrently.
+     */
     readonly reset$: import("rxjs").Observable<Event>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FormDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FormDirective, "form[odxForm]", ["odxForm"], {}, {}, never, never, true, never>;

package/components/form-field/lib/form-field.component.d.ts

@@ -6,17 +6,37 @@ import { FormFieldService } from './form-field.service';
 import { FormFieldVariant } from './models';
 import { FormFieldErrorService } from './services';
 import * as i0 from "@angular/core";
+/**
+ * Represents a form field component.
+ */
 export declare class FormFieldComponent {
     protected readonly hasWarning$$: BehaviorSubject<boolean>;
     protected readonly formGroup: FormGroupComponent | null;
     protected readonly formFieldService: FormFieldService;
     protected readonly formFieldErrorService: FormFieldErrorService;
     readonly element: ElementRef<HTMLElement>;
+    /**
+     * The label directive associated with the form field component.
+     * @see {FormFieldLabelDirective}
+     */
     labelDirective?: FormFieldLabelDirective;
+    /**
+     * The control element of the form field component.
+     */
     controlElement: ElementRef<HTMLDivElement>;
+    /**
+     * The label of the form field component.
+     */
     label?: string | null;
+    /**
+     * Indicates whether the form field should have a warning.
+     */
     set hasWarning(value: boolean);
     get hasWarning(): boolean;
+    /**
+     * The variant of the form field.
+     * @see {FormFieldVariant}
+     */
     variant: FormFieldVariant | null;
     get hasLabel(): boolean;
     constructor();

package/components/form-field/lib/form-field.service.d.ts

@@ -7,19 +7,61 @@ interface FieldControl {
     control: AbstractControl;
     nativeElement: HTMLElement;
 }
+/**
+ * Provides centralized form field management for Angular applications.
+ * This service handles the registration and management of form controls, including their disabled and read-only states,
+ * and integrates seamlessly with Angular's forms module. It manages the state of individual form fields across the application,
+ * ensuring that changes to the state (such as disabled or read-only) are consistently reflected in the UI.
+ *
+ * Extends the `Controller` class, which provides basic functionality for managing state and interactions.
+ * The service utilizes Angular's dependency injection to access and manipulate form controls and their properties,
+ * making it easier to maintain and update form state across complex forms.
+ *
+ * @extends {Controller}
+ */
 export declare class FormFieldService extends Controller implements OnDestroy {
     private readonly disabledController;
     private readonly readonlyController;
     private readonly control$$;
+    /**
+     * Observable that emits the currently registered control object, which includes
+     * both the control instance and the associated native HTML element.
+     */
     readonly control$: Observable<FieldControl | null>;
+    /**
+     * Observable that emits the ID of the current control's HTML element. Generates a unique ID if not already assigned.
+     */
     readonly controlId$: Observable<string | null>;
+    /**
+     * Observable that emits the hint ID associated with the control, which is typically used for accessibility purposes.
+     */
     readonly controlHintId$: Observable<string | null>;
+    /**
+     * Observable that emits the error message ID associated with the control, used for linking form errors for accessibility.
+     */
     readonly controlErrorId$: Observable<string | null>;
+    /**
+     * Observable that emits a boolean indicating whether the control is disabled, combining both internal state and controller state.
+     */
     readonly isDisabled$: Observable<boolean>;
+    /**
+     * Observable that emits a boolean indicating whether the control is required, based on the presence of the required attribute or validator.
+     */
     readonly isRequired$: Observable<boolean>;
+    /**
+     * Observable that emits a boolean indicating whether the control is readonly, based on the presence of the readonly attribute.
+     */
     readonly isReadonly$: Observable<boolean>;
     ngOnDestroy(): void;
+    /**
+     * Registers a control along with its native element to the service.
+     * @param {AbstractControl} control - The Angular form control.
+     * @param {ElementRef<HTMLElement>} nativeElement - The native element associated with the form control.
+     */
     registerControl(control: AbstractControl, { nativeElement }: ElementRef<HTMLElement>): void;
+    /**
+     * Removes the currently registered control from the service.
+     */
     removeControl(): void;
     private updateControlDisabledState;
     private getControlDisabledState;

package/components/form-field/lib/services/form-field-error.service.d.ts

@@ -2,15 +2,39 @@ import { OnDestroy, TemplateRef } from '@angular/core';
 import { ValidationErrors } from '@angular/forms';
 import { FormFieldError } from '../models';
 import * as i0 from "@angular/core";
+/**
+ * Manages and resolves form field errors by integrating custom error messages and templates.
+ * This service provides reactive observables for error states that can be used to display custom error messages in templates.
+ * It supports both string-based error messages and Angular templates for richer error displays.
+ */
 export declare class FormFieldErrorService implements OnDestroy {
     private readonly config;
     private readonly fieldError$$;
     private readonly customErrors$$;
+    /**
+     * An Observable that emits the resolved form field error based on current validations and custom errors.
+     * It outputs either a `FormFieldError` object with a message and context or `null` if no errors are found.
+     */
     readonly error$: import("rxjs").Observable<FormFieldError | null>;
+    /**
+     * An Observable that emits a boolean indicating whether there are any active errors.
+     */
     readonly hasError$: import("rxjs").Observable<boolean>;
+    /**
+     * Gets a boolean indicating whether the current field has any errors.
+     */
     get hasError(): boolean;
     ngOnDestroy(): void;
+    /**
+     * Sets the first relevant error from the ValidationErrors object if any error matches the non-ignored error list.
+     * @param errors ValidationErrors object containing potential errors from a form control.
+     */
     setError(errors?: ValidationErrors | null): void;
+    /**
+     * Registers a custom error template for a specific error key.
+     * @param key The error key to register the custom template under. If omitted, a default key is used.
+     * @param template A TemplateRef instance containing the Angular template to display for this error.
+     */
     registerCustomError(key: string | undefined, template: TemplateRef<unknown>): void;
     private getFirstError;
     private resolveError;

package/components/header/lib/directives/header-avatar.directive.d.ts

@@ -1,5 +1,9 @@
 import { AfterViewInit } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Directive for the header avatar component.
+ * This directive is responsible for customizing the appearance of the header avatar button.
+ */
 export declare class HeaderAvatarDirective implements AfterViewInit {
     private readonly button;
     ngAfterViewInit(): void;

package/components/header/lib/directives/header-title.directive.d.ts

@@ -1,4 +1,7 @@
 import * as i0 from "@angular/core";
+/**
+ * Directive for displaying the title in the header component.
+ */
 export declare class HeaderTitleDirective {
     static ɵfac: i0.ɵɵFactoryDeclaration<HeaderTitleDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<HeaderTitleDirective, "odx-header-title", never, {}, {}, never, never, true, never>;

package/components/header/lib/header.component.d.ts

@@ -1,4 +1,7 @@
 import * as i0 from "@angular/core";
+/**
+ * Represents the header component.
+ */
 export declare class HeaderComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
     static ɵfac: i0.ɵɵFactoryDeclaration<HeaderComponent, never>;

package/components/header-navigation/lib/directives/header-navigation-link.directive.d.ts

@@ -4,6 +4,9 @@ export declare class HeaderNavigationRouterLinkDirective {
     static ɵfac: i0.ɵɵFactoryDeclaration<HeaderNavigationRouterLinkDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<HeaderNavigationRouterLinkDirective, "[routerLink][odxHeaderNavigationLink]", never, {}, {}, never, never, true, [{ directive: typeof i1.RouterLinkActive; inputs: { "routerLinkActiveOptions": "routerLinkActiveOptions"; }; outputs: {}; }]>;
 }
+/**
+ * Directive for handling header navigation links.
+ */
 export declare class HeaderNavigationLinkDirective {
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<HeaderNavigationLinkDirective, never>;

package/components/header-navigation/lib/header-navigation.component.d.ts

@@ -1,6 +1,12 @@
 import * as i0 from "@angular/core";
+/**
+ * Represents the header navigation component.
+ */
 export declare class HeaderNavigationComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Indicates whether the header navigation should be centered.
+     */
     centered: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<HeaderNavigationComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<HeaderNavigationComponent, "odx-header-navigation", never, { "centered": { "alias": "centered"; "required": false; }; }, {}, never, ["ng-template, [odxHeaderNavigationLink]"], true, never>;

package/components/icon/lib/helpers/unpack-icon-identifier.d.ts

@@ -1 +1,15 @@
+/**
+ * Unpacks a combined icon identifier string into separate icon set and icon name components.
+ * The identifier is expected to follow the format "iconSet::iconName". If the "iconName" part is
+ * missing, the function assumes the icon belongs to the 'core' set.
+ *
+ * @param value The combined identifier string in the format "iconSet::iconName".
+ * @returns A tuple containing the icon set and icon name as two separate strings. Defaults to 'core'
+ *          if the iconName is omitted in the input.
+ *
+ * @example
+ * ```ts
+ * unpackIconIdentifier("menu")       // returns ['core', 'menu']
+ * ```
+ */
 export declare function unpackIconIdentifier(value: string): [iconSet: string, iconName: string];

package/components/icon/lib/icon.component.d.ts

@@ -1,11 +1,35 @@
 import { IconSize } from './models';
 import * as i0 from "@angular/core";
+/**
+ * Represents an icon component that can dynamically display various icons based on input properties. This component
+ * leverages CSS for styling and is designed to be easily embedded within other components and views.
+ *
+ * It allows for specifying icon sets and individual icon names, supporting flexible usage across different contexts
+ * and themes. The component is also optimized for performance with Angular's OnPush change detection strategy.
+ */
 export declare class IconComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Determines whether the icon should be displayed inline with text or other elements.
+     */
     inline: boolean;
+    /**
+     * Specifies the size of the icon, which can be adjusted using predefined sizes from the IconSize enum.
+     * @see {IconSize}
+     */
     size: IconSize;
+    /**
+     * The name of the icon to be displayed, which corresponds to specific icons within a given icon set.
+     */
     name: string | null;
+    /**
+     * Specifies the icon set that the icon belongs to. The default set can be injected from the icon configuration.
+     */
     iconSet: string | null;
+    /**
+     * Allows for setting both the icon set and icon name via a single identifier, typically formatted as 'set::name'.
+     * Unpacking this identifier sets both `name` and `iconSet` properties.
+     */
     set identifier(value: string | null | undefined);
     static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "odx-icon", never, { "inline": { "alias": "inline"; "required": false; }; "size": { "alias": "size"; "required": false; }; "name": { "alias": "name"; "required": false; }; "iconSet": { "alias": "iconSet"; "required": false; }; "identifier": { "alias": "identifier"; "required": false; }; }, {}, never, never, true, never>;

package/components/icon/lib/icon.config.d.ts

@@ -1,4 +1,30 @@
+/**
+ * Represents the configuration options for icons in the application, specifying defaults
+ * and configurations for the icon components used across the system.
+ *
+ * @typedef {Object} IconConfig
+ * @property {string} defaultIconSet - The default set of icons to use if no specific set is provided.
+ */
 export interface IconConfig {
     defaultIconSet: string;
 }
+/**
+ * Utility functions generated to handle the injection and provision of the `IconConfig`.
+ * These include tokens and functions for accessing and providing icon configurations.
+ *
+ * - `IconConfig`: A type representing the shape of the icon configuration object.
+ * - `IconDefaultConfig`: The default configuration which sets 'core' as the default icon set.
+ * - `injectIconConfig`: A function to inject the icon configuration, usable in Angular components or services.
+ * - `provideIconConfig`: A function to provide the icon configuration, typically used in Angular module providers.
+ *
+ * @example
+ * ```ts
+ * // To inject icon configuration in a component or service
+ * const config = injectIconConfig();
+ * console.log(config.defaultIconSet); // Outputs: 'core'
+ *
+ * // To provide icon configuration in a module
+ * provideIconConfig({ defaultIconSet: 'custom' });
+ * ```
+ */
 export declare const IconConfig: import("@angular/core").InjectionToken<Partial<IconConfig>>, IconDefaultConfig: IconConfig, injectIconConfig: () => IconConfig, provideIconConfig: <D extends import("@odx/angular/utils").ConfigDependencies<unknown> = import("@odx/angular/utils").ConfigDependencies<Partial<IconConfig>>>(config: import("@odx/angular/utils").ConfigProvider<Partial<IconConfig>, D>) => import("@angular/core").FactoryProvider | import("@angular/core").ValueProvider;

package/components/inline-message/lib/inline-message.component.d.ts

@@ -1,8 +1,21 @@
 import { InlineMessageVariant } from './models';
 import * as i0 from "@angular/core";
+/**
+ * Represents an inline message component used for displaying contextual feedback to users.
+ * This component can show different types of messages such as warnings, errors, successes, or informational messages,
+ * each with corresponding icons. It leverages the `IconComponent` to render these icons.
+ */
 export declare class InlineMessageComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Determines the type of message to display, which influences the icon and styling.
+     * Default is `InlineMessageVariant.DEFAULT`, which is typically styled as an informational message.
+     * @see {InlineMessageVariant}
+     */
     variant?: InlineMessageVariant | null;
+    /**
+     * Getter for the icon name based on the current variant.
+     */
     get icon(): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<InlineMessageComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<InlineMessageComponent, "odx-inline-message", never, { "variant": { "alias": "variant"; "required": false; }; }, {}, never, ["*"], true, never>;

package/components/link/link.directive.d.ts

@@ -1,5 +1,8 @@
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular";
+/**
+ * Represents a link directive.
+ */
 export declare class LinkDirective {
     readonly element: import("@angular/core").ElementRef<HTMLLinkElement>;
     static ɵfac: i0.ɵɵFactoryDeclaration<LinkDirective, never>;

package/components/list/lib/components/expandable-list-item/expandable-list-item.component.d.ts

@@ -1,6 +1,12 @@
 import { ExpandableItemDirective } from '@odx/angular/cdk/expandable';
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular/cdk/expandable";
+/**
+ * Represents a component that serves as an expandable list item within an application.
+ * It uses animations for expanding and collapsing content, and it integrates seamlessly
+ * with other components such as buttons and icons for interactive elements.
+ * @see {ExpandableItemDirective}
+ */
 export declare class ExpandableListItemComponent {
     protected readonly expandableItem: ExpandableItemDirective;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;

package/components/list/lib/components/list-item/list-item.component.d.ts

@@ -3,15 +3,31 @@ import { NgChanges } from '@odx/angular/utils';
 import { ListItemVariant } from '../../models';
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular";
+/**
+ * Represents a stylable list item component that can be easily integrated within Angular applications.
+ * It supports various visual variants, disabled and selected states, and can be used both as a standalone or
+ * as an element in a larger list or collection of items.
+ */
 export declare class ListItemComponent implements OnChanges {
     private readonly withTabIndex;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
     /**
-     * @deprecated Use `variant` instead
+     * Marks the list item as potentially harmful or attention-needing, affecting its style and appearance.
+     * @deprecated Use `variant` instead.
      */
     danger: boolean;
+    /**
+     * Specifies the visual variant of the list item.
+     * @see {ListItemVariant}
+     */
     variant: ListItemVariant;
+    /**
+     * Marks the list item as disabled, preventing user interaction and changing its appearance.
+     */
     muted: boolean;
+    /**
+     * Marks the list item as selected, changing its appearance to indicate its state.
+     */
     selected: boolean;
     ngOnChanges(changes: NgChanges<ListItemComponent>): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ListItemComponent, never>;

package/components/list/lib/list.component.d.ts

@@ -1,5 +1,10 @@
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular/cdk/expandable";
+/**
+ * Represents a list component that can optionally act as an expandable container. This component can be used
+ * to display a list of items where each item might be individually expandable.
+ * @see {ExpandableContainerDirective}
+ */
 export declare class ListComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ListComponent, never>;

package/components/loading-spinner/lib/loading-spinner.component.d.ts

@@ -1,11 +1,19 @@
 import { AnimationEvent } from '@angular/animations';
 import { OnInit } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Represents a loading spinner component.
+ */
 export declare class LoadingSpinnerComponent implements OnInit {
     private readonly host;
     private readonly windowRef;
     protected backgroundColor: string | null;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Indicates whether the color of the loading spinner should be automatically determined.
+     * If set to true, the color will be based on the theme of the parent container.
+     * If set to false, the color will be the default color specified in the component's styles.
+     */
     autoColor: boolean;
     ngOnInit(): void;
     protected animationFinished({ toState }: AnimationEvent): void;

package/components/loading-spinner/lib/loading-spinner.directive.d.ts

@@ -1,4 +1,10 @@
 import * as i0 from "@angular/core";
+/**
+ * A directive that controls the display of a loading spinner overlay on the host element.
+ * This directive can dynamically create or remove a loading spinner based on the `isLoading` state.
+ * It modifies the host element's styles to ensure the spinner is displayed correctly, and optionally,
+ * it can set a minimum height to prevent layout shifts.
+ */
 export declare class LoadingSpinnerDirective {
     private readonly dynamicViewService;
     private readonly hostElement;
@@ -7,10 +13,26 @@ export declare class LoadingSpinnerDirective {
     private readonly windowRef;
     private parentMinHeight?;
     private viewRef;
+    /**
+     * Whether the spinner should automatically adjust its color based on the background.
+     * Allows the user to specify if the spinner should use automatic color adjustment.
+     */
     autoColor: boolean;
+    /**
+     * Controls whether the spinner is visible or not.
+     * Manages the loading state, showing or hiding the spinner accordingly.
+     */
     set isLoading(value: boolean);
     get isLoading(): boolean;
+    /**
+     * Sets the minimum height for the host element when the spinner is active, to avoid layout shifts.
+     * Specifies the minimum height for the spinner's parent element.
+     */
     set minHeight(value: number);
+    /**
+     * Resets styles applied to the parent element when the spinner is removed.
+     * Removes the class, minHeight, and position styles.
+     */
     resetParentStyles(): void;
     private setParentHeight;
     private createSpinner;

package/components/logo/logo.directive.d.ts

@@ -1,8 +1,23 @@
 import { LogoSize, LogoVariant } from './models';
 import * as i0 from "@angular/core";
+/**
+ * A directive that handles the presentation of a logo with configurable size and variant.
+ */
 export declare class LogoDirective {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * The size of the logo.
+     *
+     * @type {LogoSize}
+     * @default LogoSize.SMALL
+     */
     size: LogoSize;
+    /**
+     * The variant of the logo.
+     *
+     * @type {LogoVariant}
+     * @default LogoVariant.DEFAULT
+     */
     variant: LogoVariant;
     static ɵfac: i0.ɵɵFactoryDeclaration<LogoDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<LogoDirective, "odx-logo", never, { "size": { "alias": "size"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, never, never, true, never>;

package/components/main-menu/lib/directives/main-menu-button.directive.d.ts

@@ -1,8 +1,12 @@
 import * as i0 from "@angular/core";
+/**
+ * Represents a directive for a main menu button.
+ * This directive is used to toggle the main menu.
+ */
 export declare class MainMenuButtonDirective {
     private readonly mainMenuService;
     readonly element: import("@angular/core").ElementRef<HTMLButtonElement>;
-    onClick(): void;
+    protected onClick(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<MainMenuButtonDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<MainMenuButtonDirective, "button[odxMainMenuButton]", never, {}, {}, never, never, true, never>;
 }

package/components/main-menu/lib/directives/main-menu-close.directive.d.ts

@@ -1,4 +1,7 @@
 import * as i0 from "@angular/core";
+/**
+ * Represents a directive for closing the main menu.
+ */
 export declare class MainMenuCloseDirective {
     private readonly mainMenu;
     protected onClick(): void;