@odx/angular 12.26.1 → 13.0.0

package/components/form-field/index.d.ts

@@ -1,7 +1,398 @@
-export * from './lib/components';
-export * from './lib/directives';
-export * from './lib/form-field.component';
-export * from './lib/form-field.module';
-export * from './lib/models';
-export * from './lib/services';
-export * from './lib/form-field.config';
+import * as i0 from '@angular/core';
+import { OnDestroy, ElementRef, TemplateRef, AfterContentInit, QueryList, OnInit } from '@angular/core';
+import { AbstractControl, ValidationErrors } from '@angular/forms';
+import * as i8 from '@odx/angular';
+import { Controller } from '@odx/angular';
+import * as rxjs from 'rxjs';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { DynamicContent, DynamicTextContent } from '@odx/angular/cdk/dynamic-view';
+import * as _odx_angular_utils from '@odx/angular/utils';
+
+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}
+ */
+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.
+     *
+     * @emits {FieldControl | null}
+     */
+    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.
+     *
+     * @emits {string | null}
+     */
+    readonly controlId$: Observable<string | null>;
+    /**
+     * Observable that emits the hint ID associated with the control, which is typically used for accessibility
+     * purposes.
+     *
+     * @emits {string | null}
+     */
+    readonly controlHintId$: Observable<string | null>;
+    /**
+     * Observable that emits the error message ID associated with the control,
+     * used for linking form errors for accessibility.
+     *
+     * @emits {string | null}
+     */
+    readonly controlErrorId$: Observable<string | null>;
+    /**
+     * Observable that emits a boolean indicating whether the control is disabled,
+     * combining both internal state and controller state.
+     *
+     * @emits {boolean}
+     */
+    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.
+     *
+     * @emits {boolean}
+     */
+    readonly isRequired$: Observable<boolean>;
+    /**
+     * Observable that emits a boolean indicating whether the control is readonly,
+     * based on the presence of the readonly attribute.
+     *
+     * @emits {boolean}
+     */
+    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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormFieldService>;
+}
+
+interface FormFieldError {
+    key: string;
+    message: DynamicContent;
+    context?: {
+        $implicit: unknown;
+    };
+}
+
+type FormFieldErrorResolver<C = boolean> = (context: C) => DynamicTextContent;
+interface FormFieldErrorResolvers {
+    min?: FormFieldErrorResolver<{
+        min: number;
+        actual: number;
+    }>;
+    max?: FormFieldErrorResolver<{
+        max: number;
+        actual: number;
+    }>;
+    required?: FormFieldErrorResolver;
+    requiredTrue?: FormFieldErrorResolver;
+    email?: FormFieldErrorResolver;
+    minlength?: FormFieldErrorResolver<{
+        requiredLength: number;
+        actualLength: number;
+    }>;
+    maxlength?: FormFieldErrorResolver<{
+        requiredLength: number;
+        actualLength: number;
+    }>;
+    pattern?: FormFieldErrorResolver<{
+        requiredPattern: string;
+    }>;
+    [key: string]: FormFieldErrorResolver<any> | undefined;
+}
+
+type FormFieldVariant = (typeof FormFieldVariant)[keyof typeof FormFieldVariant];
+declare const FormFieldVariant: {
+    readonly FULL: "full";
+    readonly SIMPLE: "simple";
+    readonly HORIZONTAL: "horizontal";
+};
+
+/**
+ * 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.
+ */
+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.
+     *
+     * @type {FormFieldError}
+     * @default null
+     */
+    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>;
+}
+
+/**
+ * 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.
+ */
+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.
+     *
+     * @emits {FormFieldError | null}
+     */
+    readonly error$: rxjs.Observable<FormFieldError | null>;
+    /**
+     * An Observable that emits a boolean indicating whether there are any active errors.
+     *
+     * @emits {boolean}
+     */
+    readonly hasError$: rxjs.Observable<boolean>;
+    /**
+     * Gets a boolean indicating whether the current field has any errors.
+     *
+     * @returns {boolean}
+     */
+    get hasError(): boolean;
+    ngOnDestroy(): void;
+    /**
+     * Sets the first relevant error from the ValidationErrors object if any error matches the non-ignored error list.
+     *
+     * @param {ValidationErrors | null} 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 {string | undefined} key The error key to register the custom template under. If omitted, a default key is used.
+     * @param {TemplateRef<unknown>} 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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldErrorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormFieldErrorService>;
+}
+
+/**
+ * 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.
+ */
+declare class FormGroupComponent implements AfterContentInit {
+    readonly element: i0.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.
+     *
+     * @type {Observable<FormFieldError | null> | null}
+     * @default null
+     */
+    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.
+     *
+     * @type {QueryList<FormFieldErrorService>}
+     */
+    formFieldErrorServices: QueryList<FormFieldErrorService>;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormGroupComponent, "odx-form-group", never, {}, {}, ["formFieldErrorServices"], ["odx-form-field", "odx-form-field-hint"], true, never>;
+}
+
+/**
+ * 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.
+ */
+declare class FormFieldControlDirective implements OnInit, OnDestroy {
+    private readonly ngControl;
+    private readonly form;
+    private readonly forceValidation$$;
+    private readonly onFormSubmit$;
+    private readonly formFieldService;
+    private readonly formFieldErrorService;
+    private readonly takeUntilDestroyed;
+    readonly element: i0.ElementRef<HTMLElement>;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private registerOnBlur;
+    private registerOnStatusChange;
+    private patchControl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldControlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormFieldControlDirective, "[odxFormFieldControl]", ["odxFormFieldControl"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive for displaying custom error messages in a form field.
+ */
+declare class FormFieldErrorDirective implements OnInit {
+    private readonly formFieldErrorService;
+    private readonly template;
+    /**
+     * The key used to identify the custom error message.
+     *
+     * @type {string | undefined}
+     */
+    key?: string;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldErrorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormFieldErrorDirective, "[odxFormFieldError]", never, { "key": { "alias": "odxFormFieldError"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive for displaying a hint within a form field.
+ */
+declare class FormFieldHintDirective {
+    protected readonly formFieldService: FormFieldService;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldHintDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormFieldHintDirective, "odx-form-field-hint", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive for the label element within a form field.
+ */
+declare class FormFieldLabelDirective {
+    readonly element: i0.ElementRef<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormFieldLabelDirective, "odx-form-field-label", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * 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.
+ */
+declare class FormDirective {
+    readonly element: i0.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.
+     *
+     * @emits {Event} The submit event emitted by the form element.
+     */
+    readonly submit$: 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.
+     *
+     * @emits {Event} The reset event emitted by the form element.
+     */
+    readonly reset$: rxjs.Observable<Event>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormDirective, "form[odxForm]", ["odxForm"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a form field component.
+ */
+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.
+     *
+     * @type {FormFieldLabelDirective | undefined}
+     */
+    labelDirective?: FormFieldLabelDirective;
+    /**
+     * The control element of the form field component.
+     *
+     * @type {ElementRef<HTMLDivElement>}
+     */
+    controlElement: ElementRef<HTMLDivElement>;
+    /**
+     * The label of the form field component.
+     *
+     * @type {string | null}
+     * @default null
+     */
+    label?: string | null;
+    /**
+     * Indicates whether the form field should have a warning.
+     *
+     * @type {boolean}
+     */
+    set hasWarning(value: boolean);
+    get hasWarning(): boolean;
+    /**
+     * The variant of the form field.
+     *
+     * @type {FormFieldVariant}
+     * @default FormFieldVariant.FULL
+     */
+    variant: FormFieldVariant | null;
+    /**
+     * Indicates whether the form field has a label.
+     *
+     * @type {boolean}
+     */
+    get hasLabel(): boolean;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldComponent, "odx-form-field", never, { "label": { "alias": "label"; "required": false; }; "hasWarning": { "alias": "hasWarning"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, ["labelDirective"], ["odx-form-field-label", "[odxFormFieldPrefix]", "*", "[odxFormFieldSuffix]", "odx-form-field-hint"], true, never>;
+    static ngAcceptInputType_hasWarning: unknown;
+}
+
+declare class FormFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormFieldModule, never, [typeof FormFieldComponent, typeof FormGroupComponent, typeof FormDirective, typeof FormFieldControlDirective, typeof FormFieldErrorDirective, typeof FormFieldHintDirective, typeof FormFieldLabelDirective], [typeof i8.CoreModule, typeof FormFieldComponent, typeof FormGroupComponent, typeof FormDirective, typeof FormFieldControlDirective, typeof FormFieldErrorDirective, typeof FormFieldHintDirective, typeof FormFieldLabelDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormFieldModule>;
+}
+
+declare const FormFieldDefaultConfig: FormFieldConfig;
+interface FormFieldConfig {
+    /**
+     * Object of error resolvers used to resolve error messages globally
+     * @default {}
+     */
+    errors: FormFieldErrorResolvers;
+    ignoreErrors: string[];
+}
+declare const FormFieldConfig: i0.InjectionToken<Partial<FormFieldConfig>>;
+declare const injectFormFieldConfig: () => FormFieldConfig;
+declare const provideFormFieldConfig: <D extends _odx_angular_utils.ConfigDependencies = _odx_angular_utils.ConfigDependencies<Partial<FormFieldConfig>>>(config: _odx_angular_utils.ConfigProvider<Partial<FormFieldConfig>, D>) => i0.FactoryProvider | i0.ValueProvider;
+
+export { FormDirective, FormFieldComponent, FormFieldConfig, FormFieldControlDirective, FormFieldDefaultConfig, FormFieldErrorDirective, FormFieldErrorService, FormFieldHintDirective, FormFieldInfoComponent, FormFieldLabelDirective, FormFieldModule, FormFieldVariant, FormGroupComponent, injectFormFieldConfig, provideFormFieldConfig };
+export type { FormFieldError, FormFieldErrorResolver, FormFieldErrorResolvers };

package/components/header/index.d.ts

@@ -1,3 +1,44 @@
-export * from './lib/directives';
-export * from './lib/header.component';
-export * from './lib/header.module';
+import * as i0 from '@angular/core';
+import { AfterViewInit } from '@angular/core';
+import * as i4 from '@odx/angular/components/main-menu';
+import * as i5 from '@odx/angular/components/action-group';
+import * as i6 from '@odx/angular/components/icon';
+import * as i7 from '@odx/angular/components/button';
+import * as i8 from '@odx/angular/components/avatar';
+import * as i9 from '@odx/angular';
+
+/**
+ * Directive for the header avatar component.
+ * This directive is responsible for customizing the appearance of the header avatar button.
+ */
+declare class HeaderAvatarDirective implements AfterViewInit {
+    private readonly button;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderAvatarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HeaderAvatarDirective, "button[odxButton][odxHeaderAvatar]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive for displaying the title in the header component.
+ */
+declare class HeaderTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HeaderTitleDirective, "odx-header-title", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the header component.
+ */
+declare class HeaderComponent {
+    readonly element: i0.ElementRef<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderComponent, "odx-header", never, {}, {}, never, ["button[odxMainMenuButton]", "odx-header-title", "*", "odx-search-bar", "odx-action-group, odx-auth, odx-institution-assignment", "[odxHeaderAvatar]"], true, never>;
+}
+
+declare class HeaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HeaderModule, never, [typeof HeaderComponent, typeof HeaderTitleDirective, typeof HeaderAvatarDirective, typeof i4.MainMenuModule, typeof i5.ActionGroupComponent, typeof i6.IconComponent, typeof i7.ButtonComponent, typeof i8.AvatarComponent], [typeof i9.CoreModule, typeof HeaderComponent, typeof HeaderTitleDirective, typeof HeaderAvatarDirective, typeof i4.MainMenuModule, typeof i5.ActionGroupComponent, typeof i6.IconComponent, typeof i7.ButtonComponent, typeof i8.AvatarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HeaderModule>;
+}
+
+export { HeaderAvatarDirective, HeaderComponent, HeaderModule, HeaderTitleDirective };

package/components/header-navigation/index.d.ts

@@ -1,3 +1,41 @@
-export * from './lib/directives';
-export * from './lib/header-navigation.component';
-export * from './lib/header-navigation.module';
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/router';
+import * as i3 from '@odx/angular';
+
+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.
+ */
+declare class HeaderNavigationLinkDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderNavigationLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HeaderNavigationLinkDirective, "[odxHeaderNavigationLink]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the header navigation component.
+ */
+declare class HeaderNavigationComponent {
+    readonly element: i0.ElementRef<HTMLElement>;
+    /**
+     * Indicates whether the header navigation should be centered.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    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>;
+    static ngAcceptInputType_centered: unknown;
+}
+
+declare class HeaderNavigationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderNavigationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HeaderNavigationModule, never, [typeof HeaderNavigationComponent, typeof HeaderNavigationLinkDirective, typeof HeaderNavigationRouterLinkDirective], [typeof i3.CoreModule, typeof HeaderNavigationComponent, typeof HeaderNavigationLinkDirective, typeof HeaderNavigationRouterLinkDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HeaderNavigationModule>;
+}
+
+export { HeaderNavigationComponent, HeaderNavigationLinkDirective, HeaderNavigationModule, HeaderNavigationRouterLinkDirective };

package/components/icon/index.d.ts

@@ -1,4 +1,154 @@
-export * from './lib/helpers';
-export * from './lib/icon.component';
-export * from './lib/icon.config';
-export * from './lib/models';
+import * as _angular_core from '@angular/core';
+import { OdxIconName, OdxIconSet } from '@odx/icons';
+import * as _odx_angular_utils from '@odx/angular/utils';
+
+type IconSet = (typeof IconSet)[keyof typeof IconSet];
+/**
+ * @deprecated Use `OdxIconSet` from `@odx/icons` instead. This type is retained for backward compatibility and will be removed in future releases.
+ */
+declare const IconSet: {
+    readonly CORE: "core";
+    readonly MEDICAL: "medical";
+    readonly SAFETY: "safety";
+    readonly UIB_LEGACY: "uib-legacy";
+};
+
+type IconSize = (typeof IconSize)[keyof typeof IconSize];
+declare const IconSize: {
+    /**
+     * @deprecated Use `sm` instead.
+     */
+    readonly SMALL: "small";
+    readonly SM: "sm";
+    /**
+     * @deprecated Use `md` instead.
+     */
+    readonly MEDIUM: "medium";
+    readonly MD: "md";
+    /**
+     * @deprecated Use `lg` instead.
+     */
+    readonly LARGE: "large";
+    readonly LG: "lg";
+    readonly XS: "xs";
+    readonly XL: "xl";
+    /**
+     * @deprecated Use `xxl` instead.
+     */
+    readonly XLARGE: "xlarge";
+    readonly XXL: "xxl";
+    readonly INLINE: "inline";
+};
+
+/**
+ * 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 {string} value The combined identifier string in the format "iconSet::iconName".
+ * @returns {[iconSet: string, iconName: string]} 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']
+ * ```
+ */
+declare function unpackIconIdentifier(value: string): [iconSet: IconSet, iconName: string];
+/**
+ * Determines if a given string is a valid icon set.
+ *
+ * @param {string} value The value to check if it is a valid icon set.
+ * @returns {boolean} Whether the value is a valid icon set.
+ *
+ * @example
+ * ```ts
+ * isIconSet('core')       // returns true
+ * isIconSet('custom')     // returns false
+ * ```
+ */
+declare function isIconSet(value: string): value is IconSet;
+
+/**
+ * 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.
+ */
+declare class IconComponent {
+    readonly element: _angular_core.ElementRef<HTMLElement>;
+    /**
+     * Specifies the size of the icon, which can be adjusted using predefined sizes from the IconSize enum.
+     *
+     * @type {IconSize}
+     * @default IconSize.MEDIUM
+     */
+    set size(value: IconSize);
+    get size(): IconSize | null;
+    /**
+     * The name of the icon to be displayed, which corresponds to specific icons within a given icon set.
+     *
+     * @type {OdxIconName | null}
+     * @default null
+     */
+    set name(value: OdxIconName | (string & {}) | null);
+    get name(): OdxIconName | (string & {}) | null;
+    /**
+     * Specifies the icon set that the icon belongs to. The default set can be injected from the icon configuration.
+     *
+     * @type {OdxIconSet | null}
+     */
+    set set(value: OdxIconSet | (string & {}) | null);
+    get set(): OdxIconSet | (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 `set` properties.
+     *
+     * @param {string | null | undefined} value - The identifier to unpack.
+     * @deprecated Use `name` and `set` properties directly instead of the `identifier` input for better clarity and separation of concerns.
+     */
+    set identifier(value: string | null | undefined);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconComponent, "odx-icon", never, { "size": { "alias": "size"; "required": false; }; "name": { "alias": "name"; "required": false; }; "set": { "alias": "set"; "required": false; }; "identifier": { "alias": "identifier"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * 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 {OdxIconSet} defaultIconSet - The default set of icons to use if no specific set is provided.
+ *
+ * @deprecated The `defaultIconSet` property is deprecated and will be removed in future versions. Please specify the icon set directly on the component.
+ */
+interface IconConfig {
+    defaultIconSet: OdxIconSet;
+}
+/**
+ * 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' });
+ * ```
+ *
+ * @deprecated The `defaultIconSet` property in the configuration is deprecated. Please specify the icon set directly on the component instead of relying on a default configuration.
+ */
+declare const IconConfig: _angular_core.InjectionToken<Partial<IconConfig>>;
+declare const IconDefaultConfig: IconConfig;
+declare const injectIconConfig: () => IconConfig;
+declare const provideIconConfig: <D extends _odx_angular_utils.ConfigDependencies = _odx_angular_utils.ConfigDependencies<Partial<IconConfig>>>(config: _odx_angular_utils.ConfigProvider<Partial<IconConfig>, D>) => _angular_core.FactoryProvider | _angular_core.ValueProvider;
+
+export { IconComponent, IconConfig, IconDefaultConfig, IconSet, IconSize, injectIconConfig, isIconSet, provideIconConfig, unpackIconIdentifier };