@odx/angular 6.0.0 → 6.0.1

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>;

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

@@ -1,3 +1,12 @@
 import { ValueProvider } from '@angular/core';
 import { ModalRef } from '../models';
+/**
+ * Provides a configuration for the Angular dependency injection system to inject a specific instance of `ModalRef`.
+ * This function is particularly useful when you want to configure a provider for a `ModalRef` within an Angular module or component.
+ *
+ * @template D The data type expected by the modal.
+ * @template R The result type that the modal will produce.
+ * @param {ModalRef<D, R>} modalRef An instance of `ModalRef` to be provided.
+ * @returns {ValueProvider} An Angular value provider that can be used in module or component providers arrays.
+ */
 export declare function provideModalRef<D = unknown, R = unknown>(modalRef: ModalRef<D, R>): ValueProvider;

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

@@ -2,6 +2,10 @@ import { Injector, OnChanges } from '@angular/core';
 import { DynamicContent, DynamicTextContent } from '@odx/angular/cdk/dynamic-view';
 import { NgChanges } from '@odx/angular/utils';
 import * as i0 from "@angular/core";
+/**
+ * A component that represents a modal dialog with dynamic content and customizable animations.
+ * It supports both modal and sidesheet variants with configurable animations for each type.
+ */
 export declare class ModalComponent implements OnChanges {
     protected readonly modalRef: import("@odx/angular/components/modal").ModalRef<unknown, unknown>;
     protected readonly injector: Injector;
@@ -9,9 +13,30 @@ export declare class ModalComponent implements OnChanges {
         $implicit: import("@odx/angular/components/modal").ModalRef<unknown, unknown>;
     };
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Size of the modal as a CSS modifier based on modal options.
+     *
+     * @type {ModalSize}
+     */
     size: import("@odx/angular/components/modal").ModalSize;
+    /**
+     * Variant of the modal as a CSS modifier that influences animation choices.
+     *
+     * @type {ModalVariant}
+     */
     variant: import("@odx/angular/components/modal").ModalVariant;
+    /**
+     * Boolean that indicates if the content is a component type rather than a template.
+     *
+     * @type {boolean}
+     */
     withComponent: boolean;
+    /**
+     * Dynamic content to be loaded into the modal. Excludes simple textual content
+     * to enable complex Angular components or templates.
+     *
+     * @type {Exclude<DynamicContent, DynamicTextContent>}
+     */
     content: Exclude<DynamicContent, DynamicTextContent>;
     constructor();
     ngOnChanges(changes: NgChanges<ModalComponent>): void;

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

@@ -1,3 +1,36 @@
 import { ModalInstanceOptions } from './models';
 export type ModalConfig = Omit<ModalInstanceOptions, 'id' | 'host' | 'data'>;
+/**
+ * Utilizes `createConfigTokens` to create configuration tokens and utility functions for managing modal configurations.
+ * This setup enables easy injection and provision of default global settings for modals throughout the application,
+ * fostering consistency and ease of customization.
+ *
+ * The generated tokens and functions include:
+ * - `ModalDefaultConfig`: The default configuration values for modals.
+ * - `ModalConfig`: An Angular `InjectionToken` for injecting modal configuration into components or services.
+ * - `injectModalConfig`: A utility function for retrieving the current modal configuration, considering any overrides.
+ * - `provideModalConfig`: A function that allows specifying overrides to the default modal configuration.
+ *
+ * @example
+ * ```ts
+ * // Example of providing a custom modal configuration in an Angular module
+ * @NgModule({
+ *   providers: [
+ *     provideModalConfig({
+ *       size: ModalSize.LARGE,
+ *       dismissable: false
+ *     })
+ *   ]
+ * })
+ * class AppModule {}
+ *
+ * // Example of injecting modal configuration in a component
+ * @Component({...})
+ * export class MyComponent {
+ *   constructor(@Inject(ModalConfig) private modalConfig: ModalConfig) {
+ *     console.log(this.modalConfig.size); // Outputs the size from the provided or default configuration
+ *   }
+ * }
+ * ```
+ */
 export declare const ModalDefaultConfig: ModalConfig, ModalConfig: import("@angular/core").InjectionToken<Partial<ModalConfig>>, injectModalConfig: () => ModalConfig, provideModalConfig: <D extends import("@odx/angular/utils").ConfigDependencies<unknown> = import("@odx/angular/utils").ConfigDependencies<Partial<ModalConfig>>>(config: import("@odx/angular/utils").ConfigProvider<Partial<ModalConfig>, D>) => import("@angular/core").ValueProvider | import("@angular/core").FactoryProvider;

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

@@ -2,16 +2,45 @@ import { EventEmitter, OnChanges, OnDestroy, TemplateRef } from '@angular/core';
 import { NgChanges } from '@odx/angular/utils';
 import { ModalOptions } from './models';
 import * as i0 from "@angular/core";
+/**
+ * A directive that simplifies the creation and management of modals directly from Angular templates.
+ * It allows for declarative modal instantiation with full control over modal options, and supports
+ * capturing modal close and dismiss events.
+ *
+ * Usage:
+ * Apply `odxModal` to an `<ng-template>` element and bind it to modal options.
+ */
 export declare class ModalDirective implements OnChanges, OnDestroy {
     private readonly modalService;
     private modalRef;
     protected readonly template: TemplateRef<any>;
+    /**
+     * Options for the modal directive.
+     *
+     * @type {Partial<ModalOptions> | '' | null}
+     */
     modalOptions?: Partial<ModalOptions> | '' | null;
+    /**
+     * Event emitter for closing the modal.
+     *
+     * @emits {any} The result of the modal close event.
+     */
     modalClose: EventEmitter<any>;
+    /**
+     * Event emitter for dismissing the modal.
+     *
+     * @emits {any} The result of the modal dismiss event.
+     */
     modalDismiss: EventEmitter<any>;
     ngOnChanges(changes: NgChanges<ModalDirective>): void;
     ngOnDestroy(): void;
+    /**
+     * Opens the modal based on the provided template and options. Binds modal result and dismissal outputs to EventEmitter properties.
+     */
     open(): void;
+    /**
+     * Dismisses the currently opened modal.
+     */
     dismiss(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ModalDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ModalDirective, "ng-template[odxModal]", ["odxModal"], { "modalOptions": { "alias": "odxModal"; "required": false; }; }, { "modalClose": "odxModalClose"; "modalDismiss": "odxModalDismiss"; }, never, never, true, never>;

package/components/modal/lib/modal.service.d.ts

@@ -2,18 +2,72 @@ import { Location } from '@angular/common';
 import { TemplateRef } from '@angular/core';
 import { BasicModalOptions, GetModalActionData, ModalOptions, ModalRef, ModalType } from './models';
 import * as i0 from "@angular/core";
+/**
+ * Service for managing modal dialogs within the application. It supports creating, opening,
+ * and dismissing modals dynamically, with comprehensive options for customization and lifecycle management.
+ * Utilizes Angular's dynamic view management to instantiate and render modals as needed.
+ *
+ * @example
+ * ```ts
+ * // Example of using ModalService to open a modal
+ * constructor(private modalService: ModalService) {}
+ *
+ * openModal() {
+ *   const modalRef = this.modalService.open(MyModalContentComponent, {
+ *     data: { someData: 'test' },
+ *     size: ModalSize.SMALL,
+ *   });
+ *
+ *   modalRef.onClose$.subscribe(result => {
+ *     console.log('Modal closed with result:', result);
+ *   });
+ * }
+ * ```
+ */
 export declare class ModalService {
     private readonly config;
     private readonly openModals;
     private readonly injector;
     private readonly dynamicViewService;
+    /**
+     * An observable that emits the current value of the openModals subject.
+     *
+     * @emits {ModalRef[]} openModals$ - The current array of open modals.
+     */
     readonly openModals$: import("rxjs").Observable<(ModalRef<unknown, unknown> & {
         id: string | number;
     })[]>;
     constructor(location: Location);
+    /**
+     * Dismisses all open modals.
+     */
     dismissAll(): void;
+    /**
+     * Retrieves the modal reference by its ID.
+     *
+     * @template Data The type of data passed to the modal.
+     * @template Result The type of result returned by the modal.
+     * @param id The ID of the modal.
+     * @returns The modal reference if found, otherwise null.
+     */
     getModalById<Data = unknown, Result = unknown>(id: ModalOptions['id']): ModalRef<Data, Result> | null;
+    /**
+     * Creates a modal with the specified options.
+     * @param modal - The basic modal options.
+     * @param options - Additional modal options.
+     * @returns The reference to the created modal.
+     */
     create<Data extends BasicModalOptions, Result = GetModalActionData<Data>>(modal: Data, options?: Partial<ModalOptions<Data>>): ModalRef<Data, Result>;
+    /**
+     * Creates and opens a new modal with the specified content and options.
+     *
+     * @template Data - The type of data passed to the modal for use in its content.
+     * @template Result - The type of result expected when the modal is closed.
+     * @template T - The content type of the modal, either a `TemplateRef` or a component.
+     * @param {ModalType<T, Data, Result> | TemplateRef<T>} content - The content of the modal, either as a `TemplateRef` or a component type.
+     * @param {Partial<ModalOptions<Data>>} [options] - Optional configuration options for the modal.
+     * @returns {ModalRef<Data, Result>} A reference to the newly opened modal, allowing interaction with and control over the modal instance.
+     */
     open<Data, Result, T>(content: TemplateRef<T>, options?: Partial<ModalOptions<Data>>): ModalRef<Data, Result>;
     open<Data, Result, T = unknown>(content: ModalType<T, Data, Result>, options?: Partial<ModalOptions<Data>>): ModalRef<Data, Result>;
     private attachModal;