@odx/angular 5.7.4 → 6.0.1

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;

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

@@ -2,9 +2,25 @@ import { RouterLinkActive } from '@angular/router';
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular";
 import * as i2 from "./main-menu-close.directive";
+/**
+ * Represents a directive for a main menu item.
+ * This directive is used to define a main menu item.
+ * Has host directives for disabled state, tabindex, and closing the main menu.
+ *
+ * @see {WithDisabledState}
+ * @see {WithTabIndex}
+ * @see {MainMenuCloseDirective}
+ */
 export declare class MainMenuItemDirective {
     protected readonly routerLinkActive: RouterLinkActive | null;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Optionally specifies whether the menu item is selected.
+     * If not specified, the menu item will not be selected.
+     *
+     * @type {boolean}
+     * @default false
+     */
     isSelected: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<MainMenuItemDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<MainMenuItemDirective, "[odxMainMenuItem]", never, { "isSelected": { "alias": "isSelected"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.WithDisabledState; inputs: {}; outputs: {}; }, { directive: typeof i1.WithTabIndex; inputs: {}; outputs: {}; }, { directive: typeof i2.MainMenuCloseDirective; inputs: {}; outputs: {}; }]>;

package/components/main-menu/lib/helpers/create-main-menu-links.d.ts

@@ -1,3 +1,4 @@
 import { Observable } from 'rxjs';
 import { MainMenuLink } from '../models';
+/** @internal */
 export declare function createMainMenuLinks$(): Observable<MainMenuLink[]>;

package/components/main-menu/lib/main-menu.component.d.ts

@@ -2,17 +2,59 @@ import { DynamicTextContent } from '@odx/angular/cdk/dynamic-view';
 import { trackByIndex } from '@odx/angular/utils';
 import { MainMenuService } from './main-menu.service';
 import * as i0 from "@angular/core";
+/**
+ * The `MainMenuComponent` provides a comprehensive user interface component for displaying a navigation menu within an application.
+ * It supports dynamic content for titles, subtitles, and copyright text, and can dynamically render additional links.
+ * The menu includes animations for opening and closing states, and can be controlled programmatically or via user interaction.
+ */
 export declare class MainMenuComponent {
     protected readonly mainMenuService: MainMenuService;
     protected readonly mainMenuLinks$: import("rxjs").Observable<import("./models").MainMenuLink[]>;
     protected readonly trackByIndex: typeof trackByIndex;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Input property for the title of the menu. The content is dynamic, allowing complex content structures
+     * like translations or custom components.
+     *
+     * @type {DynamicTextContent}
+     */
     title: DynamicTextContent;
+    /**
+     * Optional input property for the subtitle of the menu.
+     *
+     * @type {DynamicTextContent | null}
+     * @default null
+     */
     subtitle?: DynamicTextContent | null;
+    /**
+     * Optional input property for the copyright text of the menu.
+     *
+     * @type {DynamicTextContent | null}
+     * @default null
+     */
     copyright?: DynamicTextContent | null;
+    /**
+     * Input property to control the open state of the menu. Uses boolean transformation to handle true/false states.
+     * Changing this property will toggle the menu's open state via the MainMenuService.
+     *
+     * @param {boolean} value - The open state of the menu.
+     */
     set isOpen(value: boolean);
+    /**
+     * Returns the current open state of the menu from the MainMenuService.
+     *
+     * @returns {boolean} `true` if the menu is open, `false` otherwise.
+     */
     get isOpen(): boolean;
+    /**
+     * Outputs the observable that tracks the open state of the menu.
+     *
+     * @emits {boolean} The open state of the menu.
+     */
     menuOpen: import("rxjs").Observable<boolean>;
+    /**
+     * Closes the menu.
+     */
     close(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<MainMenuComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<MainMenuComponent, "odx-main-menu", never, { "title": { "alias": "title"; "required": true; }; "subtitle": { "alias": "subtitle"; "required": false; }; "copyright": { "alias": "copyright"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; }, { "menuOpen": "menuOpen"; }, never, ["*", "[odxLink]"], true, never>;

package/components/main-menu/lib/main-menu.config.d.ts

@@ -9,4 +9,35 @@ export interface MainMenuLinksConfig {
     statusUrl?: string | null;
     dynamicLinks?: Observable<MainMenuLink[]>;
 }
+/**
+ * Tokens generated to provide and inject `MainMenuLinksConfig`. These tokens are used to configure and access main menu links throughout the application.
+ *
+ * @exports
+ * - `MainMenuLinksConfig` - Token for injecting the config.
+ * - `MainMenuLinksDefaultConfig` - Default configuration for main menu links.
+ * - `injectMainMenuLinksConfig` - Function to inject the config wherever needed.
+ * - `provideMainMenuLinksConfig` - Provider function to configure and provide the config in Angular's DI system.
+ *
+ * @example
+ * ```ts
+ * // Providing main menu links in an Angular module
+ * @NgModule({
+ *  providers: [
+ *   provideMainMenuLinksConfig({
+ *     legalNoticeUrl: 'https://example.com/legalnotice',
+ *     providerIdentificationUrl: 'https://example.com/provideridentification',
+ *    }),
+ *   ],
+ *  })
+ * export class AppModule { }
+ *
+ * // Injecting and using the main menu links configuration in a component
+ * @Component({ ... })
+ * export class MyComponent {
+ *  constructor(@Inject(MainMenuLinksConfig) private config: MainMenuLinksConfig) {
+ *   console.log('Legal Notice URL:', config.legalNoticeUrl);
+ *  }
+ * }
+ * ```
+ */
 export declare const MainMenuLinksConfig: import("@angular/core").InjectionToken<Partial<MainMenuLinksConfig>>, MainMenuLinksDefaultConfig: MainMenuLinksConfig, injectMainMenuLinksConfig: () => MainMenuLinksConfig, provideMainMenuLinksConfig: <D extends import("@odx/angular/utils").ConfigDependencies<unknown> = import("@odx/angular/utils").ConfigDependencies<Partial<MainMenuLinksConfig>>>(config: import("@odx/angular/utils").ConfigProvider<Partial<MainMenuLinksConfig>, D>) => import("@angular/core").FactoryProvider | import("@angular/core").ValueProvider;

package/components/main-menu/lib/main-menu.service.d.ts

@@ -1,10 +1,38 @@
 import * as i0 from "@angular/core";
+/**
+ * Provides control over the state of the main menu, allowing components to open, close, or toggle its visibility.
+ * This service uses a BehaviorSubject to manage the open state and exposes an observable that emits the current state.
+ */
 export declare class MainMenuService {
     private readonly isOpen$$;
+    /**
+     * An Observable that emits the current state of the menu's visibility.
+     * It uses distinctUntilChanged to prevent unnecessary emissions when the state hasn't actually changed.
+     * shareReplay is configured to cache the last value for any late subscribers.
+     *
+     * @emits {boolean} The current visibility state of the main menu.
+     */
     readonly isOpen$: import("rxjs").Observable<boolean>;
+    /**
+     * Returns the current visibility state of the main menu.
+     *
+     * @returns {boolean} True if the menu is open, false otherwise.
+     */
     isOpen(): boolean;
+    /**
+     * Opens the main menu by setting its state to true.
+     */
     open(): void;
+    /**
+     * Closes the main menu by setting its state to false.
+     */
     close(): void;
+    /**
+     * Toggles the visibility state of the main menu.
+     *
+     * @param {boolean | undefined} forceState - If provided, the menu will be set to this specific state. If not provided,
+     * the menu will toggle to the opposite of its current state.
+     */
     toggle(forceState?: boolean): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<MainMenuService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MainMenuService>;

package/components/mainfilter-group/lib/mainfilter-group.component.d.ts

@@ -1,4 +1,8 @@
 import * as i0 from "@angular/core";
+/**
+ * Represents the MainfilterGroupComponent class.
+ * This component is responsible for styling the main filter group.
+ */
 export declare class MainfilterGroupComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
     static ɵfac: i0.ɵɵFactoryDeclaration<MainfilterGroupComponent, never>;

package/components/menu/lib/directives/menu-item.directive.d.ts

@@ -1,5 +1,11 @@
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular/cdk/a11y";
+/**
+ * Represents a directive for a menu item.
+ * Uses the `ListFocusManagerOptionDirective` to manage focus within the menu items.
+ *
+ * @see {ListFocusManagerOptionDirective}
+ */
 export declare class MenuItemDirective {
     readonly element: import("@angular/core").ElementRef<HTMLButtonElement | HTMLLinkElement>;
     protected selectItem(): void;

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

@@ -1,9 +1,21 @@
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular/cdk/a11y";
+/**
+ * `MenuComponent` provides an Angular component for creating a navigational menu structure in an application.
+ * It utilizes the `ListFocusManagerDirective` to manage focus within the menu items and integrates with other custom components like `ActionGroupComponent`.
+ * The component is styled using CSS component techniques to ensure a consistent look and feel across different parts of the application.
+ * @see {ListFocusManagerDirective}
+ */
 export declare class MenuComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * A CSS modifier that indicates if the menu should use a tile layout. This is controlled through an input property which can be bound to a boolean value.
+     *
+     * @type {boolean}
+     * @default false
+     */
     tile: boolean;
-    onTab(event: KeyboardEvent): void;
+    protected onTab(event: KeyboardEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "odx-menu", never, { "tile": { "alias": "tile"; "required": false; }; }, {}, never, ["*", "[odxButton]"], true, [{ directive: typeof i1.ListFocusManagerDirective; inputs: {}; outputs: {}; }]>;
     static ngAcceptInputType_tile: unknown;

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

@@ -4,13 +4,44 @@ import { DropdownDirective } from '@odx/angular/components/dropdown';
 import { NgChanges, Position } from '@odx/angular/utils';
 import * as i0 from "@angular/core";
 import * as i1 from "@odx/angular/components/dropdown";
+/**
+ * `MenuDirective` integrates a menu system into elements using the `DropdownDirective`
+ * for dynamic dropdown functionality.
+ * It enables flexible positioning and content injection capabilities, making it suitable
+ * for creating context menus, dropdown lists, and other interactive menu-driven components.
+ *
+ * @see {DropdownDirective}
+ */
 export declare class MenuDirective implements OnChanges {
     protected readonly dropdown: DropdownDirective;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Accepts dynamic content other than `DynamicTextContent` to be used as the content of the dropdown.
+     * This allows for more complex content structures such as templates or components to be defined
+     * as dropdown content.
+     *
+     * @type {Exclude<DynamicContent, DynamicTextContent> | null}
+     */
     content?: Exclude<DynamicContent, DynamicTextContent> | null;
+    /**
+     * Optionally specifies the positioning of the dropdown menu relative to its trigger element.
+     * If not specified, a default position may be used.
+     *
+     * @type {Position | null}
+     */
     position?: Position | null;
     ngOnChanges(changes: NgChanges<MenuDirective>): void;
+    /**
+     * Returns whether the dropdown is currently open.
+     *
+     * @returns {boolean} `true` if the dropdown is open, `false` otherwise.
+     */
     isOpen(): boolean;
+    /**
+     * Closes the dropdown.
+     *
+     * @param {Event} [event] The event that triggered the dropdown close.
+     */
     close(event?: Event): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<MenuDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<MenuDirective, "[odxMenu]", ["odxMenu"], { "content": { "alias": "odxMenu"; "required": false; }; "position": { "alias": "odxMenuPosition"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.DropdownDirective; inputs: { "odxDropdown": "odxMenu"; }; outputs: {}; }]>;

package/components/modal/lib/components/basic-modal/basic-modal.component.d.ts

@@ -2,9 +2,23 @@ import { Injector } from '@angular/core';
 import { trackByIndex } from '@odx/angular/utils';
 import { BasicModalOptions, GetModalActionData, Modal } from '../../models';
 import * as i0 from "@angular/core";
+/**
+ * Represents a basic modal component that can be used to display dynamic content, handle modal actions, and interact
+ * with other components through dependency injection. It includes common modal features such as headers, footers, and dynamic content areas.
+ * This component uses the `ModalRef` to manage its state and interactions.
+ *
+ * The `BasicModalComponent` is designed to be flexible and reusable for various modal dialog needs within an application.
+ *
+ * @template Result The expected result type that the modal might produce, typically used when the modal closes.
+ */
 export declare class BasicModalComponent<Result = unknown> implements Modal<BasicModalOptions<Result>, GetModalActionData<BasicModalOptions<Result>>> {
     protected readonly injector: Injector;
     protected readonly trackByIndex: typeof trackByIndex;
+    /**
+     * The reference to the modal.
+     *
+     * @type {ModalRef<BasicModalOptions<Result>>}
+     */
     readonly modalRef: import("../../models").ModalRef<BasicModalOptions<Result>, Exclude<Result, undefined>>;
     protected get data(): BasicModalOptions<Result>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BasicModalComponent<any>, never>;

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

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

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

@@ -1,9 +1,18 @@
 import { AfterContentInit } from '@angular/core';
 import { AreaHeaderComponent } from '@odx/angular/components/area-header';
 import * as i0 from "@angular/core";
+/**
+ * Represents the header component of a modal.
+ */
 export declare class ModalHeaderComponent implements AfterContentInit {
     protected readonly modalRef: import("@odx/angular/components/modal").ModalRef<unknown, unknown>;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * The area header component associated with the modal header.
+     *
+     * @type {AreaHeaderComponent | undefined}
+     * @remarks This component is optional.
+     */
     areaHeaderComponent?: AreaHeaderComponent;
     constructor();
     ngAfterContentInit(): void;

package/components/modal/lib/components/modal-hero/modal-hero.component.d.ts

@@ -1,10 +1,31 @@
 import { ModalHeroVariant } from '../../models';
 import * as i0 from "@angular/core";
+/**
+ * Represents a modal hero component.
+ */
 export declare class ModalHeroComponent {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * The modal reference of the modal hero component.
+     */
     readonly modalRef: import("../../models").ModalRef<unknown, unknown>;
+    /**
+     * The icon of the modal hero component.
+     *
+     * @type {string}
+     */
     icon?: string | null;
+    /**
+     * The icon set of the modal hero component.
+     *
+     * @type {string}
+     */
     iconSet: string;
+    /**
+     * The variant of the modal hero component.
+     *
+     * @type {ModalHeroVariant | null}
+     */
     variant?: ModalHeroVariant | null;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<ModalHeroComponent, never>;

package/components/modal/lib/directives/modal-close.directive.d.ts

@@ -1,8 +1,32 @@
 import * as i0 from "@angular/core";
+/**
+ * A directive that enables an element to close or dismiss a modal when clicked.
+ * It can be used on any element within a modal to trigger the close or dismiss action, optionally passing a result back to the modal opener.
+ *
+ * The directive accepts an input value that determines the result to be passed back on modal close. If no value is provided, or it's explicitly set to `null`,
+ * the modal is dismissed without sending a result. If the input value is `undefined`, the modal is dismissed via the `dismiss` method without passing any result.
+ *
+ * @template T - The type of the result to be emitted when the modal closes. Defaults to `unknown`.
+ *
+ * @example
+ * Closing a modal and passing a result:
+ * ```html
+ * <button [odxModalClose]="myResult">Close and send result</button>
+ * ```
+ *
+ * Simply dismissing a modal without passing a result:
+ * ```html
+ * <button odxModalClose>Dismiss</button>
+ * ```
+ */
 export declare class ModalCloseDirective<T = unknown> {
     private readonly modalRef;
+    /**
+     * Represents the result to be passed back to the modal opener when the modal is closed.
+     * @template T - The type of the result returned.
+     */
     result?: T | null;
-    onClick(): void;
+    protected onClick(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ModalCloseDirective<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ModalCloseDirective<any>, "[odxModalClose]", never, { "result": { "alias": "odxModalClose"; "required": false; }; }, {}, never, never, true, never>;
 }

package/components/modal/lib/directives/modal-content.directive.d.ts

@@ -1,4 +1,7 @@
 import * as i0 from "@angular/core";
+/**
+ * Represents a directive for the content of a modal.
+ */
 export declare class ModalContentDirective {
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ModalContentDirective, never>;

package/components/modal/lib/directives/modal-dismiss.directive.d.ts

@@ -1,7 +1,24 @@
 import * as i0 from "@angular/core";
+/**
+ * A directive that enables an element to dismiss a modal when clicked. This can be applied
+ * to any clickable element within a modal, such as buttons or links, to provide a declarative
+ * approach to dismissing the modal.
+ *
+ * Utilizes `injectModalRef` to access the modal reference associated with the containing modal,
+ * enabling the directive to call the `dismiss` method on the modal reference upon the click event.
+ *
+ * @example
+ * Dismissing a modal using the odxModalDismiss directive on a button:
+ * ```html
+ * <button odxModalDismiss>Cancel</button>
+ * ```
+ *
+ * This directive simplifies modal dismissal by removing the need for manually wiring click events
+ * to dismiss methods in the component class, thereby enhancing template readability and maintainability.
+ */
 export declare class ModalDismissDirective {
     private readonly modalRef;
-    onClick(): void;
+    protected onClick(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ModalDismissDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ModalDismissDirective, "[odxModalDismiss]", never, {}, {}, never, never, true, never>;
 }

package/components/modal/lib/helpers/inject-modal-ref.d.ts

@@ -1,2 +1,23 @@
 import { ModalRef } from '../models';
+/**
+ * Utility function to inject a reference to a modal. This function simplifies the injection process by typing the `ModalRef` to the specific data and result expected by the consumer.
+ *
+ * This approach abstracts away Angular's inject function, providing direct access to the modal reference with the correct type. It is commonly used in components or services that interact with a modal dialog to manipulate its data, close it, or perform other related actions.
+ *
+ * @template Data The type of data passed to the modal.
+ * @template Result The type of result expected when the modal closes.
+ * @returns {ModalRef<Data, Result>} A strongly typed reference to the modal.
+ *
+ * @example
+ * ```ts
+ * // Injecting a modal reference in a component or service:
+ * const modalRef = injectModalRef<SomeDataType, SomeResultType>();
+ *
+ * // Using the modal reference to close the modal and return a result:
+ * modalRef.close(someResult);
+ *
+ * // Accessing the data provided to the modal:
+ * const modalData = modalRef.data;
+ * ```
+ */
 export declare function injectModalRef<Data, Result = unknown>(): ModalRef<Data, Result>;