@odx/angular 12.26.1 → 13.0.0

package/components/modal/index.d.ts

@@ -1,9 +1,549 @@
-export * from './lib/components';
-export * from './lib/directives';
-export * from './lib/helpers';
-export * from './lib/modal.component';
-export * from './lib/modal.config';
-export * from './lib/modal.directive';
-export * from './lib/modal.module';
-export * from './lib/modal.service';
-export * from './lib/models';
+import * as _odx_angular_components_modal from '@odx/angular/components/modal';
+import * as i0 from '@angular/core';
+import { ViewContainerRef, Type, Injector, AfterContentInit, ValueProvider, OnChanges, OnDestroy, TemplateRef, EventEmitter } from '@angular/core';
+import { DynamicTextContent, DynamicContent } from '@odx/angular/cdk/dynamic-view';
+import * as i1 from '@odx/angular/components/button';
+import { ButtonVariant } from '@odx/angular/components/button';
+import * as rxjs from 'rxjs';
+import * as i13 from '@odx/angular';
+import { Controller } from '@odx/angular';
+import * as i14 from '@odx/angular/components/area-header';
+import { AreaHeaderComponent } from '@odx/angular/components/area-header';
+import * as _odx_angular_utils from '@odx/angular/utils';
+import { NgChanges } from '@odx/angular/utils';
+import * as i2 from '@odx/angular/components/button-group';
+
+type ModalHeroVariant = (typeof ModalHeroVariant)[keyof typeof ModalHeroVariant];
+declare const ModalHeroVariant: {
+    readonly PRIMARY: "primary";
+    readonly SUCCESS: "success";
+    readonly CONFIRMATION: "confirmation";
+    readonly DANGER: "danger";
+};
+
+interface ModalAction<Result = unknown> {
+    label: string;
+    data?: Result;
+    variant?: ButtonVariant;
+}
+type GetModalActionData<T extends BasicModalOptions> = Exclude<T['actions'][number]['data'], undefined>;
+interface BasicModalOptions<Result = unknown> {
+    title: DynamicTextContent;
+    actions: ModalAction<Result>[];
+    content?: DynamicContent;
+    heroIcon?: string;
+    heroVariant?: ModalHeroVariant;
+}
+
+type ModalSize = (typeof ModalSize)[keyof typeof ModalSize];
+declare const ModalSize: {
+    readonly XSMALL: "xsmall";
+    readonly SMALL: "small";
+    readonly MEDIUM: "medium";
+    readonly LARGE: "large";
+};
+
+type ModalVariant = typeof ModalVariant[keyof typeof ModalVariant];
+declare const ModalVariant: {
+    readonly DEFAULT: "default";
+    readonly SIDESHEET: "sidesheet";
+};
+
+interface ModalInstanceOptions {
+    id: string;
+    dismissable: boolean;
+    interactiveBackdrop: boolean;
+    size: ModalSize;
+    variant: ModalVariant;
+}
+interface ModalOptionsExtras<Data> {
+    data: Data;
+    host: Element | ViewContainerRef;
+    dismissOnNavigation: boolean;
+    canClose?: (data: Data) => boolean;
+    canDismiss?: (data: Data) => boolean;
+}
+type ModalOptions<D = unknown> = ModalInstanceOptions & ModalOptionsExtras<D>;
+
+/**
+ * A reference to a dynamically created modal, providing methods to manipulate, close, or update the modal's state
+ * and options.
+ * This class extends the `Controller` base class from `@odx/angular`, adding modal-specific functionalities like
+ * handling closures and dismissals.
+ *
+ * @template Data - The type of data passed to the modal.
+ * @template Result - The type of the result emitted when the modal is closed.
+ *
+ * @see {Controller}
+ */
+declare class ModalRef<Data = unknown, Result = unknown> extends Controller {
+    private internalOptions;
+    private readonly onClose$$;
+    private readonly onDismiss$$;
+    private readonly onDestroy$$;
+    /** An observable that emits when the modal is closed with a result. */
+    readonly onClose$: rxjs.Observable<Result>;
+    /** An observable that emits when the modal is dismissed without a result. */
+    readonly onDismiss$: rxjs.Observable<void>;
+    /** An observable that emits when modal is destroyed regardless of the trigger path. */
+    readonly onDestroy$: rxjs.Observable<void>;
+    /** A method that returns whether the modal is currently active. */
+    readonly isActive: () => boolean;
+    /** Gets the unique identifier for the modal instance.
+     *
+     * @returns {string} The unique identifier for the modal instance.
+     */
+    get id(): string;
+    /** Gets the ARIA label ID for the modal title, based on the modal's ID.
+     *
+     * @returns {string} The ARIA label ID for the modal title.
+     */
+    get modalTitleId(): string;
+    /** Gets the data passed to the modal. This is useful for modal initialization.
+     *
+     * @returns {Data} The data passed to the modal.
+     */
+    get data(): Data;
+    /** Gets the current options for the modal. These options include configurations.
+     *
+     * @template Data - The type of data passed to the modal.
+     * @returns {ModalOptions<Data>} The current options for the modal.
+     */
+    get options(): ModalOptions<Data>;
+    constructor(internalOptions: ModalOptions<Data>, isActive: (modalRef: ModalRef<Data, Result>) => boolean);
+    /**
+     * Updates the modal's options.
+     *
+     * @param {Partial<ModalOptions<Data>>} options A partial set of options to update.
+     */
+    update(options: Partial<ModalOptions<Data>>): void;
+    /**
+     * Dismisses the modal. This does not result in an output value.
+     *
+     * @param {boolean} [force=false] Whether to force dismissal regardless of the `canDismiss` condition.
+     */
+    dismiss(force?: boolean): void;
+    /**
+     * Closes the modal with a result.
+     *
+     * @param {Result} result The result to emit when the modal closes.
+     */
+    close(result: Result): void;
+    /** Completes the onClose and onDismiss streams and cleans up resources. */
+    destroy(): void;
+}
+
+interface Modal<Data, Result> {
+    readonly modalRef?: ModalRef<Data, Result>;
+}
+type ModalType<T, Data = unknown, Result = unknown> = Type<T> | {
+    new (modalRef?: ModalRef<Data, Result>): Modal<Data, Result>;
+};
+
+/**
+ * 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.
+ */
+declare class BasicModalComponent<Result = unknown> implements Modal<BasicModalOptions<Result>, GetModalActionData<BasicModalOptions<Result>>> {
+    protected readonly injector: Injector;
+    /**
+     * The reference to the modal.
+     *
+     * @type {ModalRef<BasicModalOptions<Result>>}
+     */
+    readonly modalRef: _odx_angular_components_modal.ModalRef<BasicModalOptions<Result>, Exclude<Result, undefined>>;
+    protected get data(): BasicModalOptions<Result>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BasicModalComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BasicModalComponent<any>, "odx-basic-modal", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the footer component of a modal.
+ */
+declare class ModalFooterComponent {
+    readonly element: i0.ElementRef<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalFooterComponent, "odx-modal-footer", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Represents the header component of a modal.
+ */
+declare class ModalHeaderComponent implements AfterContentInit {
+    protected readonly modalRef: _odx_angular_components_modal.ModalRef<unknown, unknown>;
+    readonly element: i0.ElementRef<HTMLElement>;
+    /**
+     * The area header component associated with the modal header.
+     *
+     * @type {AreaHeaderComponent | undefined}
+     */
+    areaHeaderComponent?: AreaHeaderComponent;
+    constructor();
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalHeaderComponent, "odx-modal-header", never, {}, {}, ["areaHeaderComponent"], ["odx-area-header"], true, never>;
+}
+
+/**
+ * Represents a modal hero component.
+ */
+declare class ModalHeroComponent {
+    readonly element: i0.ElementRef<HTMLElement>;
+    /**
+     * The modal reference of the modal hero component.
+     *
+     * @type {ModalRef}
+     */
+    readonly modalRef: _odx_angular_components_modal.ModalRef<unknown, unknown>;
+    /**
+     * The icon of the modal hero component.
+     *
+     * @example `iconSet::iconName`.
+     * @type {string}
+     */
+    icon?: string | null;
+    /**
+     * The variant of the modal hero component.
+     *
+     * @type {ModalHeroVariant | null}
+     */
+    variant?: ModalHeroVariant | null;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalHeroComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalHeroComponent, "odx-modal-hero", never, { "icon": { "alias": "icon"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * 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>
+ * ```
+ */
+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;
+    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>;
+}
+
+/**
+ * Represents a directive for the content of a modal.
+ */
+declare class ModalContentDirective {
+    readonly element: i0.ElementRef<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ModalContentDirective, "odx-modal-content", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * 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.
+ */
+declare class ModalDismissDirective {
+    private readonly modalRef;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalDismissDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ModalDismissDirective, "[odxModalDismiss]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that prevents the default form method behavior on submit buttons inside an HTML Dialog form.
+ */
+declare class PreventFormMethodDialogDirective {
+    protected onClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreventFormMethodDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PreventFormMethodDialogDirective, "[formmethod=dialog]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that prevents the default form submission behavior inside an HTML Dialog form.
+ */
+declare class PreventMethodDialogDirective {
+    protected onFormSubmit(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreventMethodDialogDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PreventMethodDialogDirective, "form[method=dialog]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * 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;
+ * ```
+ */
+declare function injectModalRef<Data, Result = unknown>(): ModalRef<Data, Result>;
+
+/**
+ * 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.
+ */
+declare function provideModalRef<D = unknown, R = unknown>(modalRef: ModalRef<D, R>): ValueProvider;
+
+/**
+ * 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.
+ */
+declare class ModalComponent implements OnChanges {
+    protected readonly modalRef: _odx_angular_components_modal.ModalRef<unknown, unknown>;
+    protected readonly injector: Injector;
+    protected readonly context: {
+        $implicit: _odx_angular_components_modal.ModalRef<unknown, unknown>;
+    };
+    readonly element: i0.ElementRef<HTMLDialogElement>;
+    /**
+     * Size of the modal as a CSS modifier based on modal options.
+     *
+     * @type {ModalSize}
+     */
+    size: _odx_angular_components_modal.ModalSize;
+    /**
+     * Variant of the modal as a CSS modifier that influences animation choices.
+     *
+     * @type {ModalVariant}
+     */
+    variant: _odx_angular_components_modal.ModalVariant;
+    /**
+     * Boolean that indicates if the content is a component type rather than a template.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    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;
+    protected preventNativeDismiss(event: KeyboardEvent): void;
+    protected handleDialogClose({ target }: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "dialog[odx-dialog-modal]", never, { "content": { "alias": "content"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * 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
+ *   }
+ * }
+ * ```
+ */
+declare const ModalDefaultConfig: ModalConfig;
+type ModalConfig = Omit<ModalInstanceOptions, 'id' | 'host' | 'data'>;
+declare const ModalConfig: i0.InjectionToken<Partial<ModalConfig>>;
+declare const injectModalConfig: () => ModalConfig;
+declare const provideModalConfig: <D extends _odx_angular_utils.ConfigDependencies = _odx_angular_utils.ConfigDependencies<Partial<ModalConfig>>>(config: _odx_angular_utils.ConfigProvider<Partial<ModalConfig>, D>) => i0.FactoryProvider | i0.ValueProvider;
+
+/**
+ * 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.
+ */
+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>;
+}
+
+declare class ModalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ModalModule, never, [typeof i1.ButtonComponent, typeof i2.ButtonGroupComponent, typeof ModalComponent, typeof ModalHeaderComponent, typeof ModalHeroComponent, typeof ModalFooterComponent, typeof ModalDirective, typeof ModalCloseDirective, typeof ModalContentDirective, typeof ModalDismissDirective, typeof PreventMethodDialogDirective, typeof PreventFormMethodDialogDirective], [typeof i13.CoreModule, typeof i14.AreaHeaderModule, typeof i1.ButtonComponent, typeof i2.ButtonGroupComponent, typeof ModalComponent, typeof ModalHeaderComponent, typeof ModalHeroComponent, typeof ModalFooterComponent, typeof ModalDirective, typeof ModalCloseDirective, typeof ModalContentDirective, typeof ModalDismissDirective, typeof PreventMethodDialogDirective, typeof PreventFormMethodDialogDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ModalModule>;
+}
+
+/**
+ * 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);
+ *   });
+ * }
+ * ```
+ */
+declare class ModalService {
+    private readonly config;
+    private readonly openModals;
+    private readonly injector;
+    private readonly dynamicViewService;
+    private readonly document;
+    /**
+     * An observable that emits the current value of the openModals subject.
+     *
+     * @emits {ModalRef[]} openModals$ - The current array of open modals.
+     */
+    readonly openModals$: rxjs.Observable<(ModalRef<unknown, unknown> & {
+        id: string | number;
+    })[]>;
+    constructor();
+    /**
+     * 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 {ModalOptions['id']} id The ID of the modal.
+     * @returns {ModalRef<Data, Result> | null} - 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.
+     * @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.
+     * @param {Data} modal - The basic modal options.
+     * @param {Partial<ModalOptions<Data>> | undefined} options - Additional modal options.
+     * @returns {ModalRef<Data, Result>} 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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModalService>;
+}
+
+export { BasicModalComponent, ModalCloseDirective, ModalComponent, ModalConfig, ModalContentDirective, ModalDefaultConfig, ModalDirective, ModalDismissDirective, ModalFooterComponent, ModalHeaderComponent, ModalHeroComponent, ModalHeroVariant, ModalModule, ModalRef, ModalService, ModalSize, ModalVariant, PreventFormMethodDialogDirective, PreventMethodDialogDirective, injectModalConfig, injectModalRef, provideModalConfig, provideModalRef };
+export type { BasicModalOptions, GetModalActionData, Modal, ModalInstanceOptions, ModalOptions, ModalOptionsExtras, ModalType };

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

@@ -1 +1,12 @@
-export * from './lib/navigation-back.component';
+import * as i0 from '@angular/core';
+
+/**
+ * Represents a navigation back component.
+ */
+declare class NavigationBackComponent {
+    readonly element: i0.ElementRef<HTMLButtonElement | HTMLLinkElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationBackComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavigationBackComponent, "button[odxNavigationBack], a[odxNavigationBack]", never, {}, {}, never, never, true, never>;
+}
+
+export { NavigationBackComponent };