@filip.mazev/blocks 1.0.28 → 1.0.40

package/types/filip.mazev-blocks-modal.d.ts

@@ -0,0 +1,615 @@
+import * as _filip_mazev_blocks_core from '@filip.mazev/blocks/core';
+import * as _angular_core from '@angular/core';
+import { Type, ComponentRef, OnInit, OnDestroy, Signal, AfterViewInit, TemplateRef, ElementRef, ViewContainerRef, InputSignal, OutputEmitterRef, QueryList, InjectionToken } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { BREAKPOINTS } from '@filip.mazev/blocks-core';
+import { ComponentType } from '@angular/cdk/portal';
+
+declare enum ModalState {
+    OPEN = "open",
+    OPENING = "opening",
+    CLOSED = "closed",
+    CLOSING = "closing"
+}
+
+type ModalCloseMode = 'cancel' | 'confirm';
+type ModalLayout = 'center' | 'right' | 'left' | 'bottom-sheet';
+type BreakpointKey = keyof typeof BREAKPOINTS;
+
+/**
+ * Interface for the Modal Close Result
+ * @param R data (optional) The result data returned when the modal is closed
+ * @param {ModalCloseMode} state (required) The state of the modal close (e.g., 'confirm', 'cancel')
+ */
+interface IModalCloseResult<R> {
+    data?: R;
+    state: ModalCloseMode;
+}
+
+/**
+ * Interface for Modal
+ * @param D The type of data passed to the modal
+ * @param R The type of result returned from the modal
+ */
+interface IModal<D, R> {
+    data: D;
+    modal: ModalRef<D, R>;
+    onModalInit(): void;
+    close(result?: R): void;
+}
+
+/**
+ * Interface for the Modal Reference
+ * @param D The type of data passed to the modal
+ * @param R The type of result returned from the modal
+ * @param C The type of the modal component, will default to IModal<D, R>
+ * @param {Type<ModalCore<D, R, C>>} modalContainer The type of the modal container component
+ * @param {ComponentRef<ModalCore<D, R, C>>} modalContainerRef The component reference of the modal container
+ * @param {HTMLElement} modalContainerElement The HTML element of the modal container
+ * @param {HTMLElement | undefined} parentElement (optional) The parent HTML element where the modal is attached
+ * @param {ComponentRef<C>} componentRef The component reference of the modal content
+ * @param {Observable<ModalState>} modalState$ Observable that emits the current state of the modal
+ * @param {ModalConfig<D> | undefined} modalConfig (optional) The configuration of the modal
+ * @param {Observable<IModalCloseResult<R | undefined>>} afterClosed Observable that emits when the modal has been closed
+ * @param {Observable<MouseEvent>} backdropClick Observable that emits when the backdrop is clicked
+ * @param {Function} open Function to open the modal
+ * @param {Function} close Function to close the modal with specified parameters
+ */
+interface IModalRef<D, R, C extends IModal<D, R> = IModal<D, R>> {
+    modalContainer: Type<ModalCore<D, R, C>>;
+    modalContainerRef: ComponentRef<ModalCore<D, R, C>>;
+    modalContainerElement: HTMLElement;
+    parentElement?: HTMLElement;
+    componentRef: ComponentRef<C>;
+    modalState$(): Observable<ModalState>;
+    modalConfig?: ModalConfig<D, R>;
+    afterClosed(): Observable<IModalCloseResult<R | undefined>>;
+    backdropClick(): Observable<MouseEvent>;
+    open(): void;
+    close: (state: 'confirm' | 'cancel', result: R | undefined, forceClose: boolean, fromSelf: boolean, from: {
+        constructor: Type<unknown>;
+    } | undefined) => void;
+}
+
+declare class ModalRef<D = unknown, R = any, C extends IModal<D, R> = IModal<D, R>> implements IModalRef<D, R, C> {
+    componentType: ComponentType<C>;
+    private modalService;
+    private _modalContainer;
+    private _modalContainerRef;
+    private _modalContainerElement;
+    private _parentElement;
+    private _componentRef;
+    private _modalState;
+    private modalState;
+    private _modalConfig?;
+    private backdropClickSubject;
+    private afterCloseSubject;
+    constructor(componentRef: ComponentRef<C>, componentType: ComponentType<C>, modalContainerRef: ComponentRef<ModalCore<D, R, C>>, modalService: ModalService, modalConfig?: ModalConfig<D, R>);
+    get modalContainer(): Type<ModalCore<D, R, C>>;
+    private set modalContainer(value);
+    get modalContainerRef(): ComponentRef<ModalCore<D, R, C>>;
+    private set modalContainerRef(value);
+    get modalContainerElement(): HTMLElement;
+    private set modalContainerElement(value);
+    get parentElement(): HTMLElement | undefined;
+    private set parentElement(value);
+    get componentRef(): ComponentRef<C>;
+    private set componentRef(value);
+    get modalConfig(): ModalConfig<D, R> | undefined;
+    private set modalConfig(value);
+    backdropClick(): Observable<MouseEvent>;
+    modalState$(): Observable<ModalState>;
+    /**
+     * Observable that emits when the modal has been closed.
+     * @returns An Observable that emits an IModalCloseResult<R | undefined> when the modal is closed.
+     */
+    afterClosed(): Observable<IModalCloseResult<R | undefined>>;
+    open(): Promise<void>;
+    close(state?: ModalCloseMode, result?: R | undefined, forceClose?: boolean): void;
+    private getStatus;
+    private backdropClicked;
+    private afterClose;
+    private handleClose;
+}
+
+/**
+ * Interface for Modal Service
+ * @param {Function} open Function to open a modal with specified component and configuration
+ * @param {Function} close Function to close a specific modal
+ * @param {Function} unregister  Function to unregister a specific modal
+ * @param {Function} closeAll Function to close all open modals
+ * @param {Function} modalsCount Function to get the count of currently open modals
+ * @param {Function} find Function to check if a modal with a specific component type is open
+ */
+interface IModalService {
+    open<D, R, C extends IModal<D, R> = IModal<D, R>>(component: ComponentType<C>, config?: IModalConfig<D, R>): ModalRef<D, R, C>;
+    close<D, R, C extends IModal<D, R> = IModal<D, R>>(modal: ModalRef<D, R, C>): void;
+    unregister<D, R, C extends IModal<D, R> = IModal<D, R>>(modal: ModalRef<D, R, C>): void;
+    closeAll(): void;
+    modalsCount(): number;
+    find<D, R>(componentType: Type<IModal<D, R>>): boolean;
+}
+
+declare class ModalService implements IModalService {
+    private readonly router;
+    private readonly injector;
+    private readonly appRef;
+    private readonly environmentInjector;
+    private readonly rendererFactory;
+    private readonly document;
+    private readonly renderer;
+    private readonly globalSettings;
+    private modals;
+    private modalsSubject;
+    constructor();
+    private createSubscriptions;
+    /**
+     * Opens a modal with the specified component and configuration.
+     * @param component The component to be displayed in the modal.
+     * @param config Optional configuration for the modal.
+     * @returns A ModalRef instance representing the opened modal.
+     */
+    open<D, R, C extends IModal<D, R> = IModal<D, R>>(component: ComponentType<C>, config?: IModalConfig<D, R>): ModalRef<D, R, C>;
+    /**
+     * Closes the specified modal.
+     * @param modal The ModalRef instance representing the modal to be closed.
+     */
+    close<D, R, C extends IModal<D, R> = IModal<D, R>>(modal: ModalRef<D, R, C>): void;
+    /**
+     * Unregisters the specified modal from the service.
+     * @param modal The ModalRef instance representing the modal to be unregistered.
+     */
+    unregister<D, R, C extends IModal<D, R> = IModal<D, R>>(modal: ModalRef<D, R, C>): void;
+    /**
+     * Closes all open modals.
+     * @param onNavigate Indicates if the closeAll is triggered by navigation event.
+     */
+    closeAll(onNavigate?: boolean): void;
+    /**
+     * Finds if a modal with the specified component type is currently open.
+     * @param componentType The component type to search for.
+     * @returns True if a modal with the specified component type is open, false otherwise.
+     */
+    find<D, R>(componentType: Type<IModal<D, R>>): boolean;
+    /**
+     * Gets the count of currently open modals.
+     * @returns The number of open modals.
+     */
+    modalsCount(): number;
+    private isIModal;
+    private resolveConfig;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ModalService>;
+}
+
+/**
+ * Abstract class representing a modal close guard.
+ */
+declare abstract class ModalCloseGuard {
+    /**
+     * Determines whether the modal can be closed.
+     */
+    abstract canClose(modalService: ModalService): Observable<boolean> | Promise<boolean> | boolean;
+}
+
+/**
+ * Interface for Bottom Sheet Modal Configuration
+ * @param {number} downSwipeLimit (optional) The limit for down swipe to close the modal (1/N of modal height needs to be reached to trigger close), will default to MODAL_DOWN_SWIPE_LIMIT = 3
+ * @param {number} customHeight (optional) Custom height for the bottom sheet modal
+ */
+interface IBottomSheetModalConfig {
+    downSwipeLimit?: number;
+    customHeight?: number;
+}
+
+/**
+ * IModalStyleConfig
+ * @param {center' | 'left' | 'right'} layout (optional) The layout of the modal (can be center, left, or right), will default to center
+ * @param {Partial<Record<BreakpointKey, ModalLayout>>} breakpoints (optional) (optional) A map of responsive overrides. It defines specific layouts for screen widths less than or equal to specific breakpoints. Defaults to undefined.
+ * @param {boolean} animate (optional) Whether the modal should have animations or not, will default to true
+ * @param {boolean} hasBackdrop (optional) Whether the modal should have a backdrop or not, will default to true
+ * @param {number} closeDelay (optional) The delay in milliseconds before the modal closes, will default to MODAL_DEFAULT_ANIM_DURATION (175)
+ * @param {boolean} showCloseButton (optional) Whether to show the close button on the modal or not, will default to true
+ * @param {IBottomSheetModalConfig} mobileConfig (optional) The configuration for the bottom-sheet modal, will default to an empty object
+ * @param {boolean} contentWrapper (optional) Whether the content should be wrapped in a default-styled div or not, will default to true
+ * @param {string} wrapperClasses (optional) The classes to apply to the wrapper of the modal
+ * @param {string} wrapperStyles (optional) The styles to apply to the wrapper of the modal
+ * @param {boolean} overrideFullHeight (optional) Whether the modal should override the full height of the modal or not, will default to false
+ */
+interface IModalStyleConfig {
+    layout?: ModalLayout;
+    breakpoints?: Partial<Record<BreakpointKey, ModalLayout>>;
+    animate?: boolean;
+    hasBackdrop?: boolean;
+    closeDelay?: number;
+    showCloseButton?: boolean;
+    mobileConfig?: IBottomSheetModalConfig;
+    contentWrapper?: boolean;
+    wrapperClasses?: string;
+    wrapperStyles?: string;
+    overrideFullHeight?: boolean;
+}
+
+/**
+ * IModalConfig<D>, the configuration for the modal
+ * @param D The type of data passed to the modal
+ * @param R The type of result returned from the modal
+ * @param {boolean} open (optional) Whether the modal should be open or not, will default to true
+ * @param {Function} afterClose (optional) The function to run after the modal closes
+ * @param {ModalCloseGuard} closeGuard (optional) The guard that will determine whether the modal can be closed or not
+ * @param {boolean} closeGuardOnlyOnCancel (optional) Whether the close guard should only be checked on cancel actions, will default to true
+ * @param {boolean} disableClose (optional) Whether the modal should be closable or not, will default to false (this applies to the close button and backdrop)
+ * @param {boolean} disableCloseOnBackdropClick (optional) Whether the modal shouldn't be closable when the user clicks on the backdrop, will default to false
+ * @param {boolean} disableCloseOnNavigation (optional) Whether the modal should be closable or not when the user navigates away from the page, will default to false
+ * @param {D | null} data (optional) The data to pass to the component of the modal. The component needs to use the @Inject(MODAL_DATA) or `data = inject<string>(MODAL_DATA);` (modern syntax) decorator to receive this.
+ * @param {IModalStyleConfig} style (optional) The style configuration for the modal, will default to an empty object
+ * @param {boolean} showCloseButton (optional) Whether the modal should show a close button or not, will default to true
+ * @param {string} bannerText (optional) The text to display in the banner of the modal
+ * @param {string} contentClasses (optional) The classes to apply to the content of the modal
+ * @param {string} contentStyles (optional) The styles to apply to the content of the modal
+ * @param {string} id (optional) The id of the modal (set at the top level of the modal), will default to a random string
+ */
+interface IModalConfig<D, R> {
+    open?: boolean;
+    afterClose?: () => Observable<IModalCloseResult<R | undefined>>;
+    closeGuard?: ModalCloseGuard;
+    closeGuardOnlyOnCancel?: boolean;
+    disableClose?: boolean;
+    disableCloseOnBackdropClick?: boolean;
+    disableCloseOnNavigation?: boolean;
+    data?: D | null;
+    style?: IModalStyleConfig;
+    bannerText?: string;
+    contentClasses?: string;
+    contentStyles?: string;
+    disableConsoleWarnings?: boolean;
+    disableConsoleInfo?: boolean;
+    id?: string;
+}
+
+declare class ModalStyleConfig implements IModalStyleConfig {
+    layout: ModalLayout;
+    breakpoints?: Partial<Record<BreakpointKey, ModalLayout>>;
+    animate: boolean;
+    hasBackdrop: boolean;
+    closeDelay?: number;
+    showCloseButton?: boolean;
+    mobileConfig: IBottomSheetModalConfig;
+    contentWrapper: boolean;
+    wrapperClasses: string;
+    wrapperStyles: string;
+    overrideFullHeight: boolean;
+    constructor(config?: IModalStyleConfig);
+}
+
+declare class ModalConfig<D, R> {
+    open: boolean;
+    afterClose?: () => Observable<IModalCloseResult<R | undefined>>;
+    closeGuard?: ModalCloseGuard;
+    closeGuardOnlyOnCancel?: boolean;
+    disableClose: boolean;
+    disableCloseOnBackdropClick: boolean;
+    disableCloseOnNavigation: boolean;
+    data: D | null;
+    style: ModalStyleConfig;
+    bannerText: string;
+    contentClasses: string;
+    contentStyles: string;
+    disableConsoleWarnings: boolean;
+    disableConsoleInfo: boolean;
+    id?: string;
+    constructor(config?: IModalConfig<D, R>);
+}
+
+/**
+ * Interface for the Modal Component
+ * @param D The type of data passed to the modal
+ * @param R The type of result returned from the modal
+ * @param C The type of the modal component, will default to IModal<D, R>
+ * @param {ComponentRef<C>} componentRef (optional) The component reference (the component that is being displayed in the modal), will default to undefined (for non-dynamic modals)
+ * @param {ModalConfig<D, R>} config (optional) The configuration for the modal, will default to default values for the configuration
+ * @param {boolean} isOpen (required) Whether the modal is open or not
+ * @param {Observable<MouseEvent>} backdropClick (required) The observable for the backdrop click event, will be used to listen for backdrop clicks (subscribed to the backdropClickSubject)
+ * @param {Function} close (required) The function to run when the modal closes, will return the result of the modal
+ */
+interface IModalComponent<D, R, C extends IModal<D, R> = IModal<D, R>> extends OnInit, OnDestroy {
+    componentRef?: ComponentRef<C>;
+    config?: ModalConfig<D, R>;
+    isOpen: Signal<boolean>;
+    backdropClick: Observable<MouseEvent>;
+    close: (state: ModalCloseMode, result: R | undefined, fromInsideInteraction: boolean, forceClose: boolean) => void;
+}
+
+declare class ModalCore<D, R, C extends IModal<D, R> = IModal<D, R>> implements IModalComponent<D, R, C>, OnInit, AfterViewInit {
+    private readonly modalService;
+    private readonly globalSettings;
+    private readonly scrollLockService;
+    private readonly windowDimensionsService;
+    readonly animationDuration: number;
+    componentRef: ComponentRef<C>;
+    config?: ModalConfig<D, R>;
+    closeFunction?: (data: IModalCloseResult<R | undefined>) => void;
+    backdropClickSubject: Subject<MouseEvent>;
+    backdropClick: Observable<MouseEvent>;
+    isOpen: _angular_core.WritableSignal<boolean>;
+    effectiveLayout: _angular_core.WritableSignal<ModalLayout>;
+    isCentered: _angular_core.WritableSignal<boolean>;
+    isSide: _angular_core.WritableSignal<boolean>;
+    isAnimated: _angular_core.Signal<boolean>;
+    protected headerTemplate: _angular_core.WritableSignal<TemplateRef<void> | null>;
+    protected footerTemplate: _angular_core.WritableSignal<TemplateRef<void> | null>;
+    protected id: _angular_core.WritableSignal<string | null>;
+    protected isBottomSheetModalActive: _angular_core.WritableSignal<boolean>;
+    protected hasBanner: boolean;
+    protected hasDefaultContentWrapperClass: boolean;
+    protected windowDimensions: _angular_core.Signal<_filip_mazev_blocks_core.WindowDimensions>;
+    protected modalContainer?: ElementRef;
+    protected contentTemplate?: TemplateRef<HTMLElement>;
+    private sideModalComponents?;
+    private centeredModalComponents?;
+    private isConfirmCloseModalOpen;
+    private scrollLockId;
+    private _sortedBreakpoints;
+    private _currentVcr;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    setHeaderTemplate(template: TemplateRef<void>): void;
+    setFooterTemplate(template: TemplateRef<void>): void;
+    close(state?: ModalCloseMode, result?: R | undefined, fromInsideInteraction?: boolean, forceClose?: boolean): void;
+    protected onBackdropClick(event: MouseEvent): void;
+    protected set dynamicContainer(vcr: ViewContainerRef | undefined);
+    private initKeyboardSubscription;
+    private initParamsFromConfig;
+    private initBreakpointCache;
+    private handleClose;
+    private handleLayout;
+    private getBottomSheetModal;
+    private resetBottomSheetModalLayout;
+    private setBottomSheetModalFinishedState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalCore<any, any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalCore<any, any, any>, "bx-modal", never, {}, {}, never, never, true, never>;
+}
+
+declare class ModalBottomSheet<D = unknown, R = unknown> implements OnInit, OnDestroy {
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly headerTemplate: _angular_core.InputSignal<TemplateRef<void> | null>;
+    readonly footerTemplate: _angular_core.InputSignal<TemplateRef<void> | null>;
+    readonly config: _angular_core.InputSignal<ModalConfig<D, R> | undefined>;
+    readonly isOpen: _angular_core.InputSignal<boolean>;
+    readonly isAnimated: _angular_core.InputSignal<boolean>;
+    readonly animationDuration: _angular_core.InputSignal<number>;
+    readonly close: _angular_core.OutputEmitterRef<ModalCloseMode | undefined>;
+    currentTranslateY: _angular_core.WritableSignal<number>;
+    isSwipingVerticallyFinished: _angular_core.WritableSignal<boolean>;
+    protected isSwipingVertically: _angular_core.WritableSignal<boolean>;
+    protected verticalSwipeTarget?: ElementRef;
+    protected elementRef?: ElementRef;
+    protected modalTransform: _angular_core.Signal<string>;
+    protected downSwipeLimit: number;
+    protected isTrackingSwipe: boolean;
+    private isTouchActive;
+    private bottomSheetInitiated;
+    private cleanupListeners;
+    private globalResizeCleanup;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private startVerticalSwipeDetection;
+    private stopVerticalSwipeDetection;
+    private initBottomSheetModalParams;
+    private monitorInputType;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalBottomSheet<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalBottomSheet<any, any>, "bx-modal-bottom-sheet", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "headerTemplate": { "alias": "headerTemplate"; "required": true; "isSignal": true; }; "footerTemplate": { "alias": "footerTemplate"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": true; "isSignal": true; }; "isAnimated": { "alias": "isAnimated"; "required": true; "isSignal": true; }; "animationDuration": { "alias": "animationDuration"; "required": true; "isSignal": true; }; }, { "close": "close"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Interface for the Modal View
+ * @param D The type of data passed to the modal
+ * @param {InputSignal<TemplateRef<void> | null>} headerTemplate The input signal for the header template of the modal
+ * @param {InputSignal<TemplateRef<void> | null>} footerTemplate The input signal for the footer template of the modal
+ * @param {InputSignal<ModalConfig<D> | undefined>} config The input signal for the modal configuration
+ * @param {InputSignal<boolean>} isOpen The input signal indicating whether the modal is open
+ * @param {InputSignal<boolean>} isAnimated The input signal indicating whether the modal has animations enabled
+ * @param {InputSignal<boolean>} isBottomSheetModalActive The input signal indicating whether the bottom sheet modal is active
+ * @param {InputSignal<number>} animationDuration The input signal for the animation duration of the modal
+ * @param {InputSignal<boolean>} hasDefaultContentWrapperClass The input signal indicating whether the modal has default content wrapper class
+ * @param {InputSignal<boolean>} hasBanner The input signal indicating whether the modal has a banner
+ * @param {OutputEmitterRef<ModalCloseMode | undefined>} close The output emitter reference for the close event of the modal
+ * @param {QueryList<ModalBottomSheet>} bottomSheet The query list of bottom sheet modals
+ * @param {Signal<{ [key: string]: boolean }>} modalClasses The signal for the modal CSS classes
+ */
+interface IModalView<D, R> {
+    headerTemplate: InputSignal<TemplateRef<void> | null>;
+    footerTemplate: InputSignal<TemplateRef<void> | null>;
+    config: InputSignal<ModalConfig<D, R> | undefined>;
+    id: InputSignal<string | null>;
+    isOpen: InputSignal<boolean>;
+    isAnimated: InputSignal<boolean>;
+    isBottomSheetModalActive: InputSignal<boolean>;
+    animationDuration: InputSignal<number>;
+    hasDefaultContentWrapperClass: InputSignal<boolean>;
+    hasBanner: InputSignal<boolean>;
+    close: OutputEmitterRef<ModalCloseMode | undefined>;
+    bottomSheet: QueryList<ModalBottomSheet>;
+    modalClasses: Signal<{
+        [key: string]: boolean;
+    }>;
+}
+
+declare class ModalSide<D = unknown, R = unknown> implements IModalView<D, R> {
+    readonly layout: _angular_core.InputSignal<ModalLayout>;
+    readonly headerTemplate: _angular_core.InputSignal<TemplateRef<void> | null>;
+    readonly footerTemplate: _angular_core.InputSignal<TemplateRef<void> | null>;
+    readonly config: _angular_core.InputSignal<ModalConfig<D, R> | undefined>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly isOpen: _angular_core.InputSignal<boolean>;
+    readonly isAnimated: _angular_core.InputSignal<boolean>;
+    readonly isBottomSheetModalActive: _angular_core.InputSignal<boolean>;
+    readonly animationDuration: _angular_core.InputSignal<number>;
+    readonly hasDefaultContentWrapperClass: _angular_core.InputSignal<boolean>;
+    readonly hasBanner: _angular_core.InputSignal<boolean>;
+    readonly close: _angular_core.OutputEmitterRef<ModalCloseMode | undefined>;
+    bottomSheet: QueryList<ModalBottomSheet>;
+    modalClasses: _angular_core.Signal<{
+        'side-modal-content-wrapper': boolean;
+        'side-modal-default-style': boolean;
+        'with-footer': boolean;
+        left: boolean;
+        right: boolean;
+        'side-modal-animate-in': boolean;
+        'side-modal-animate-out': boolean;
+    }>;
+    protected renderOpenClass: _angular_core.WritableSignal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalSide<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalSide<any, any>, "bx-modal-side", never, { "layout": { "alias": "layout"; "required": true; "isSignal": true; }; "headerTemplate": { "alias": "headerTemplate"; "required": true; "isSignal": true; }; "footerTemplate": { "alias": "footerTemplate"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; "id": { "alias": "id"; "required": true; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": true; "isSignal": true; }; "isAnimated": { "alias": "isAnimated"; "required": true; "isSignal": true; }; "isBottomSheetModalActive": { "alias": "isBottomSheetModalActive"; "required": true; "isSignal": true; }; "animationDuration": { "alias": "animationDuration"; "required": true; "isSignal": true; }; "hasDefaultContentWrapperClass": { "alias": "hasDefaultContentWrapperClass"; "required": true; "isSignal": true; }; "hasBanner": { "alias": "hasBanner"; "required": true; "isSignal": true; }; }, { "close": "close"; }, never, ["*"], true, never>;
+}
+
+declare class ModalCentered<D = unknown, R = unknown> implements IModalView<D, R> {
+    readonly headerTemplate: _angular_core.InputSignal<TemplateRef<void> | null>;
+    readonly footerTemplate: _angular_core.InputSignal<TemplateRef<void> | null>;
+    readonly config: _angular_core.InputSignal<ModalConfig<D, R> | undefined>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly isOpen: _angular_core.InputSignal<boolean>;
+    readonly isAnimated: _angular_core.InputSignal<boolean>;
+    readonly isBottomSheetModalActive: _angular_core.InputSignal<boolean>;
+    readonly animationDuration: _angular_core.InputSignal<number>;
+    readonly hasDefaultContentWrapperClass: _angular_core.InputSignal<boolean>;
+    readonly hasBanner: _angular_core.InputSignal<boolean>;
+    readonly close: _angular_core.OutputEmitterRef<ModalCloseMode | undefined>;
+    readonly onBackdropClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    bottomSheet: QueryList<ModalBottomSheet>;
+    modalClasses: _angular_core.Signal<{
+        'centered-modal-content-wrapper': boolean;
+        'centered-modal-default-style': boolean;
+        'centered-modal-animate-in': boolean;
+        'centered-modal-animate-out': boolean;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalCentered<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalCentered<any, any>, "bx-modal-centered", never, { "headerTemplate": { "alias": "headerTemplate"; "required": true; "isSignal": true; }; "footerTemplate": { "alias": "footerTemplate"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; "id": { "alias": "id"; "required": true; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": true; "isSignal": true; }; "isAnimated": { "alias": "isAnimated"; "required": true; "isSignal": true; }; "isBottomSheetModalActive": { "alias": "isBottomSheetModalActive"; "required": true; "isSignal": true; }; "animationDuration": { "alias": "animationDuration"; "required": true; "isSignal": true; }; "hasDefaultContentWrapperClass": { "alias": "hasDefaultContentWrapperClass"; "required": true; "isSignal": true; }; "hasBanner": { "alias": "hasBanner"; "required": true; "isSignal": true; }; }, { "close": "close"; "onBackdropClick": "onBackdropClick"; }, never, ["*"], true, never>;
+}
+
+declare class ModalBackdrop {
+    readonly isAnimated: _angular_core.InputSignal<boolean>;
+    readonly isOpen: _angular_core.InputSignal<boolean>;
+    readonly click: _angular_core.OutputEmitterRef<MouseEvent>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalBackdrop, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalBackdrop, "bx-modal-backdrop", never, { "isAnimated": { "alias": "isAnimated"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; }, { "click": "click"; }, never, never, true, never>;
+}
+
+declare class ModalBanner<D = unknown, R = unknown> {
+    readonly config: _angular_core.InputSignal<ModalConfig<D, R> | undefined>;
+    readonly close: _angular_core.OutputEmitterRef<ModalCloseMode | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalBanner<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalBanner<any, any>, "bx-modal-banner", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "close": "close"; }, never, never, true, never>;
+}
+
+declare class ModalGlobalSettingsService {
+    readonly layout: _angular_core.WritableSignal<ModalLayout>;
+    readonly animate: _angular_core.WritableSignal<boolean>;
+    readonly hasBackdrop: _angular_core.WritableSignal<boolean>;
+    readonly showCloseButton: _angular_core.WritableSignal<boolean>;
+    readonly contentWrapper: _angular_core.WritableSignal<boolean>;
+    readonly overrideFullHeight: _angular_core.WritableSignal<boolean>;
+    readonly disableClose: _angular_core.WritableSignal<boolean>;
+    readonly disableCloseOnBackdropClick: _angular_core.WritableSignal<boolean>;
+    readonly disableCloseOnNavigation: _angular_core.WritableSignal<boolean>;
+    readonly closeGuardOnlyOnCancel: _angular_core.WritableSignal<boolean>;
+    readonly disableConsoleWarnings: _angular_core.WritableSignal<boolean>;
+    readonly disableConsoleInfo: _angular_core.WritableSignal<boolean>;
+    /**
+     * Updates the global modal settings with the provided values. Only the specified settings will be updated, while others will remain unchanged.
+     * @param settings An object containing the settings to be updated. Each property is optional, and only those provided will be updated.
+     * Example usage:
+     * this.modalGlobalSettingsService.update({
+     *   animate: false,
+     *   hasBackdrop: true,
+     *   disableCloseOnBackdropClick: true
+     * });
+     * In this example, the global settings for 'animate', 'hasBackdrop', and 'disableCloseOnBackdropClick' will be updated, while all other settings will retain their current values.
+     */
+    update(settings: Partial<{
+        layout: ModalLayout;
+        animate: boolean;
+        hasBackdrop: boolean;
+        showCloseButton: boolean;
+        contentWrapper: boolean;
+        overrideFullHeight: boolean;
+        disableCloseOnBackdropClick: boolean;
+        disableCloseOnNavigation: boolean;
+        closeGuardOnlyOnCancel: boolean;
+        disableConsoleWarnings: boolean;
+        disableConsoleInfo: boolean;
+    }>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalGlobalSettingsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ModalGlobalSettingsService>;
+}
+
+declare class Modal<D, R> implements IModal<D, R> {
+    /**
+     * Data injected into the modal component.
+     */
+    data: D;
+    /**
+     * Reference to the ModalRef instance associated with this modal.
+     */
+    modal: ModalRef<D, R>;
+    /**
+     * Called when the modal is initialized.
+     */
+    onModalInit(): void;
+    /**
+     * Closes the modal (with "cancel" reason) with an optional result.
+     * @param result The result to be passed when closing the modal.
+     */
+    close(result?: R): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Modal<any, any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<Modal<any, any>>;
+}
+
+declare const MODAL_DEFAULT_ANIM_DURATION = 175;
+declare const MODAL_DEFAULT_INTERNAL_ANIM_DURATION = 350;
+declare const MODAL_DEFAULT_ANIM_DURATION_MULTIPLIER_SMALL = 0.65;
+declare const MODAL_DEFAULT_ANIM_DURATION_MULTIPLIER_LARGE = 0.85;
+
+declare const MODAL_DOWN_SWIPE_LIMIT = 3;
+declare const MODAL_SWIPE_VELOCITY_THRESHOLD = 80;
+
+declare enum ModalWarnings {
+    FOOTER_DIRECTIVE_OUTSIDE_MODAL = "[ModalFooter] Directive used outside of a ModalComponent.",
+    HEADER_DIRECTIVE_OUTSIDE_MODAL = "[ModalHeader] Directive used outside of a ModalComponent."
+}
+
+declare class ModalHeaderDirective {
+    private readonly templateRef;
+    private readonly modal;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ModalHeaderDirective, "[appModalHeader]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ModalFooterDirective {
+    private readonly templateRef;
+    private readonly modal;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalFooterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ModalFooterDirective, "[appModalFooter]", never, {}, {}, never, never, true, never>;
+}
+
+declare const MODAL_DATA: InjectionToken<any>;
+
+/**
+ * Modal Close Guard that opens a confirmation modal before allowing the original modal to close.
+ * @param component The component to use for the confirmation modal.
+ * @param config The configuration for the confirmation modal.
+ */
+declare class ModalConfirmCloseGuard<D, R, C extends IModal<D, R> = IModal<D, R>> extends ModalCloseGuard {
+    component: ComponentType<C>;
+    config: IModalConfig<D, R>;
+    constructor(component: ComponentType<C>, config: IModalConfig<D, R>);
+    canClose(modalService: ModalService): Observable<boolean>;
+}
+
+export { MODAL_DATA, MODAL_DEFAULT_ANIM_DURATION, MODAL_DEFAULT_ANIM_DURATION_MULTIPLIER_LARGE, MODAL_DEFAULT_ANIM_DURATION_MULTIPLIER_SMALL, MODAL_DEFAULT_INTERNAL_ANIM_DURATION, MODAL_DOWN_SWIPE_LIMIT, MODAL_SWIPE_VELOCITY_THRESHOLD, Modal, ModalBackdrop, ModalBanner, ModalBottomSheet, ModalCentered, ModalCloseGuard, ModalConfig, ModalConfirmCloseGuard, ModalCore, ModalFooterDirective, ModalGlobalSettingsService, ModalHeaderDirective, ModalRef, ModalService, ModalSide, ModalState, ModalStyleConfig, ModalWarnings };
+export type { BreakpointKey, IBottomSheetModalConfig, IModalCloseResult, IModalComponent, IModalConfig, IModalRef, IModalService, IModalStyleConfig, IModalView, ModalCloseMode, ModalLayout };