@odx/angular 5.7.4 → 6.0.1

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

@@ -2,13 +2,29 @@ import { Injector } from '@angular/core';
 import { DynamicContent } from '@odx/angular/cdk/dynamic-view';
 import { DropdownDirective } from './dropdown.directive';
 import * as i0 from "@angular/core";
+/**
+ * Represents a dropdown component.
+ */
 export declare class DropdownComponent {
     protected readonly host: DropdownDirective;
     protected readonly injector: Injector;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * The content to be displayed in the dropdown.
+     */
     content?: DynamicContent | null;
+    /**
+     * Indicates whether to show a loader while loading the dropdown content.
+     */
     showLoader?: boolean;
+    /**
+     * Indicates whether clicking outside the dropdown should close it.
+     */
     clickOutsideActive?: boolean;
+    /**
+     * Event listener for the CloseDropdownEvent.
+     * Closes the dropdown when the event is triggered.
+     */
     protected onDropdownClose(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DropdownComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<DropdownComponent, "odx-dropdown", never, { "content": { "alias": "content"; "required": false; }; "showLoader": { "alias": "showLoader"; "required": false; }; "clickOutsideActive": { "alias": "clickOutsideActive"; "required": false; }; }, {}, never, never, true, never>;

package/components/dropdown/lib/dropdown.directive.d.ts

@@ -5,6 +5,11 @@ import { DropdownOptions } from './models';
 import * as i0 from "@angular/core";
 export declare const DEFAULT_DROPDOWN_OPEN_TRIGGERS: string[];
 export declare const DEFAULT_DROPDOWN_CLOSE_TRIGGERS: string[];
+/**
+ * Represents a directive that enables dropdown functionality in Angular.
+ * This directive handles the opening and closing of a dropdown menu, as well as
+ * managing the associated overlay and event handling.
+ */
 export declare class DropdownDirective implements AfterViewInit, OnChanges, OnDestroy {
     private readonly changeDetector;
     private readonly connectedOverlayService;
@@ -13,26 +18,88 @@ export declare class DropdownDirective implements AfterViewInit, OnChanges, OnDe
     private readonly injector;
     private overlayRef;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Gets a value indicating whether the dropdown is currently open.
+     */
     get isOpen(): boolean;
+    /**
+     * The content to be displayed in the dropdown.
+     * It can be either a static content or a dynamically loaded content.
+     */
     content?: DynamicContent | null;
+    /**
+     * Indicates whether the dropdown is disabled or not.
+     */
     disabled: boolean;
+    /**
+     * Indicates whether the loader should be shown.
+     */
     showLoader: boolean;
+    /**
+     * Determines whether the dropdown should close when a click event occurs outside of it.
+     */
     clickOutsideActive: boolean;
+    /**
+     * The options to be used when creating the dropdown overlay.
+     */
     options?: Partial<DropdownOptions> | null;
+    /**
+     * The reference element to which the dropdown is anchored.
+     */
     referenceElement?: HTMLElement | null;
+    /**
+     * The trigger element that opens the dropdown.
+     */
     triggerElement?: HTMLElement | null;
+    /**
+     * The host element to which the dropdown is appended.
+     */
     host?: HTMLElement | ViewContainerRef | null;
+    /**
+     * The event triggers that open the dropdown.
+     */
     openTrigger?: string[] | null;
+    /**
+     * The event triggers that close the dropdown.
+     */
     closeTrigger?: string[] | null;
+    /**
+     * Event emitter that emits before the dropdown is opened.
+     */
     beforeOpen: EventEmitter<void>;
+    /**
+     * Event emitter that emits after the dropdown is opened.
+     */
     afterOpen: EventEmitter<void>;
+    /**
+     * Event emitter that emits before the dropdown is closed.
+     */
     beforeClose: EventEmitter<void>;
+    /**
+     * Event emitter that emits after the dropdown is closed.
+     */
     afterClose: EventEmitter<void>;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
     ngOnChanges(changes: NgChanges<DropdownDirective>): void;
+    /**
+     * Toggles the state of the dropdown.
+     * If the dropdown is open, it will be closed. If it is closed, it will be opened.
+     *
+     * @param event - The optional event that triggered the toggle.
+     */
     toggle(event?: Event): void;
+    /**
+     * Opens the dropdown.
+     *
+     * @param event - The optional event that triggered the open.
+     */
     open(event?: Event): void;
+    /**
+     * Closes the dropdown.
+     *
+     * @param event - The optional event that triggered the close.
+     */
     close(event?: Event): void;
     private createOverlayOptions;
     static ɵfac: i0.ɵɵFactoryDeclaration<DropdownDirective, never>;

package/components/dropdown/lib/helpers/close-current-dropdown.d.ts

@@ -1 +1,6 @@
+/**
+ * Dispatches a CloseDropdownEvent for target to close the current dropdown.
+ *
+ * @param target - The target element to close the dropdown for.
+ */
 export declare function closeCurrentDropdown(target: Element): void;

package/components/error-page/lib/error-page.component.d.ts

@@ -1,6 +1,13 @@
 import * as i0 from "@angular/core";
+/**
+ * Represents the ErrorPageComponent class.
+ * This component is responsible for displaying an error page.
+ */
 export declare class ErrorPageComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Represents the options for the error page component.
+     */
     options: import("./error-page.config").ErrorPageConfig;
     static ɵfac: i0.ɵɵFactoryDeclaration<ErrorPageComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ErrorPageComponent, "odx-error-page", never, {}, {}, never, never, true, never>;

package/components/error-page/lib/error-page.config.d.ts

@@ -1,6 +1,16 @@
 import { EnvironmentProviders } from '@angular/core';
 import { DynamicContent } from '@odx/angular/cdk/dynamic-view';
 import { ConfigDependencies, ConfigProvider } from '@odx/angular/utils';
+/**
+ * Defines the configuration for an error page used within an application. This can include custom icons,
+ * titles, descriptions, actions, and an optional error message.
+ * @property {string} [icon] - The name of the icon to display on the error page.
+ * @property {string} [iconSet] - The icon set that the icon belongs to.
+ * @property {DynamicContent} title - The title content for the error page, which can be a string or a dynamic template.
+ * @property {DynamicContent} [description] - Optional description content for the error page.
+ * @property { { label: DynamicContent; action: () => void; }[] } actions - A list of actions that can be taken from the error page, each with a label and an action function.
+ * @property {DynamicContent} [errorMessage] - Optional additional error message content.
+ */
 export interface ErrorPageConfig {
     icon?: string;
     iconSet?: string;
@@ -13,4 +23,12 @@ export interface ErrorPageConfig {
     errorMessage?: DynamicContent;
 }
 export declare const ErrorPageConfig: import("@angular/core").InjectionToken<Partial<ErrorPageConfig>>, ErrorPageDefaultConfig: ErrorPageConfig, injectErrorPageConfig: () => ErrorPageConfig, provideErrorPageConfig: <D extends ConfigDependencies<unknown> = ConfigDependencies<Partial<ErrorPageConfig>>>(config: ConfigProvider<Partial<ErrorPageConfig>, D>) => import("@angular/core").FactoryProvider | import("@angular/core").ValueProvider;
+/**
+ * Configures and provides the necessary providers for an error page, using a configuration object that specifies
+ * icons, titles, descriptions, and actions.
+ *
+ * @param {ConfigProvider<Partial<ErrorPageConfig>, D>} config - A configuration object or provider function that supplies an `ErrorPageConfig`.
+ * @returns {EnvironmentProviders} Returns a configuration that can be used to register the error page providers.
+ *
+ */
 export declare function configureErrorPage<D extends ConfigDependencies>(config: ConfigProvider<Partial<ErrorPageConfig>, D>): EnvironmentProviders;

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;