@filip.mazev/modal 0.1.26 → 0.1.28

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

@@ -1,39 +1,227 @@
 import * as _filip_mazev_blocks_core from '@filip.mazev/blocks-core';
+import { BREAKPOINTS } from '@filip.mazev/blocks-core';
 import * as _angular_core from '@angular/core';
-import { Type, ComponentRef, ViewContainerRef, Renderer2, Injector, OnDestroy, OnInit, Signal, TemplateRef, ElementRef, InputSignal, OutputEmitterRef, QueryList, InjectionToken } from '@angular/core';
-import { Observable, Subject } from 'rxjs';
+import { Type, ComponentRef, OnInit, OnDestroy, Signal, TemplateRef, ElementRef, InputSignal, OutputEmitterRef, QueryList, ViewContainerRef, InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
 import { ComponentType } from '@angular/cdk/portal';
-import * as _filip_mazev_modal from '@filip.mazev/modal';
+
+declare enum ModalState {
+    OPEN = "open",
+    OPENING = "opening",
+    CLOSED = "closed",
+    CLOSING = "closing"
+}
 
 type ModalCloseMode = "cancel" | "confirm";
-type ModalPoistion = "center" | "right" | "left";
+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>>} 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>;
+    afterClosed(): Observable<IModalCloseResult<R>>;
+    backdropClick(): Observable<MouseEvent>;
+    open(): void;
+    close: (state: "confirm" | "cancel", result: R | undefined, forceClose: boolean, fromSelf: boolean, from: {
+        constructor: Function;
+    } | 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 set modalContainer(value);
+    get modalContainer(): Type<ModalCore<D, R, C>>;
+    private _modalContainerRef;
+    private set modalContainerRef(value);
+    get modalContainerRef(): ComponentRef<ModalCore<D, R, C>>;
+    private _modalContainerElement;
+    private set modalContainerElement(value);
+    get modalContainerElement(): HTMLElement;
+    private _parentElement;
+    private set parentElement(value);
+    get parentElement(): HTMLElement | undefined;
+    private _componentRef;
+    private set componentRef(value);
+    get componentRef(): ComponentRef<C>;
+    private _modalState;
+    private modalState;
+    modalState$(): Observable<ModalState>;
+    private getStatus;
+    private _modalConfig?;
+    private set modalConfig(value);
+    get modalConfig(): ModalConfig<D> | undefined;
+    private backdropClickSubject;
+    backdropClick(): Observable<MouseEvent>;
+    private backdropClicked;
+    private afterCloseSubject;
+    /**
+     * Observable that emits when the modal has been closed.
+     * @returns An Observable that emits an IModalCloseResult<R> when the modal is closed.
+     */
+    afterClosed(): Observable<IModalCloseResult<R>>;
+    private afterClose;
+    constructor(componentRef: ComponentRef<C>, componentType: ComponentType<C>, modalContainerRef: ComponentRef<ModalCore<D, R, C>>, modalService: ModalService, modalConfig?: ModalConfig<D>);
+    open(): Promise<void>;
+    close(state?: ModalCloseMode, result?: R | undefined, forceClose?: boolean): void;
+    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>): 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 router;
+    private injector;
+    private appRef;
+    private environmentInjector;
+    private rendererFactory;
+    private renderer;
+    private document;
+    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>): 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;
+    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 IGenericSwipeableModalConfig {
+/**
+ * Interface for Bottom Sheet Modal Configuration
+ * @param {number} downSwipeLimit (optional) The limit for down swipe to close the modal
+ * @param {number} customHeight (optional) Custom height for the bottom sheet modal
+ */
+interface IBottomSheetModalConfig {
     downSwipeLimit?: number;
     customHeight?: number;
 }
 
 /**
- * IGenericModalStyleConfig
- * @param {center' | 'left' | 'right'} position (optional) The position of the modal (can be center, left, or right), will default to center
- * @param {boolean} handleMobile (optional) Whether the modal should open in a mobile configuration when going to a certain screen size
+ * 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) The breakpoints for responsive layouts, will default 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 GENERIC_MODAL_DEFAULT_ANIM_DURATION (175)
- * @param {IGenericSwipeableModalConfig} mobileConfig (optional) The configuration for the swipeable modal, will default to an empty object
+ * @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 IGenericModalStyleConfig {
-    position?: ModalPoistion;
-    handleMobile?: boolean;
+interface IModalStyleConfig {
+    layout?: ModalLayout;
+    breakpoints?: Partial<Record<BreakpointKey, ModalLayout>>;
     animate?: boolean;
     hasBackdrop?: boolean;
     closeDelay?: number;
     showCloseButton?: boolean;
-    mobileConfig?: IGenericSwipeableModalConfig;
+    mobileConfig?: IBottomSheetModalConfig;
     contentWrapper?: boolean;
     wrapperClasses?: string;
     wrapperStyles?: string;
@@ -41,54 +229,37 @@ interface IGenericModalStyleConfig {
 }
 
 /**
- * Interface for the Generic Confirm Close Modal
- * @param {ComponentType<any>} confirmModalComponent The component to use for the confirm modal
- * @param {boolean} confirmClose (required) Whether the modal should confirm close or not
- * @param {boolean} confirmOnSubmit (optional) Whether the modal should confirm on submit or not, will default to false (if false, will only need to confirm when close state is 'cancel')
- * @param {IGenericModalStyleConfig} style (optional) The style configuration for the modal
- * @param {D | null} data (optional) The data to pass to the component of the modal, the component needs to have the @Inject(GENERIC_MODAL_DATA) data: any; decorator to receive this data
- * @param {string} bannerText (optional) The text to display in the banner of the modal
- * @param {boolean} bypassSelfCheck (optional) Whether the modal should bypass the self check or not, will default to false (if true, will not check if the modal is the same as the one that opened it)
- */
-interface IGenericConfirmCloseConfig<ConfirmComponentData = any, ConfirmComponent extends GenericModal<ConfirmComponentData, undefined> = GenericModal<ConfirmComponentData, undefined>> {
-    confirmModalComponent: ComponentType<ConfirmComponent>;
-    confirmClose: boolean;
-    confirmOnSubmit?: boolean;
-    style?: IGenericModalStyleConfig;
-    data?: ConfirmComponentData | null;
-    bannerText?: string;
-    bypassSelfCheck?: boolean;
-}
-
-/**
- * IGenericModalConfig<D>, the configuration for the generic modal
+ * IModalConfig<D>, the configuration for the modal
+ * @param D The type of data passed to 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 {IGenericConfirmCloseConfig<ConfirmComponent, ConfirmComponentData>} confirmCloseConfig (optional) The configuration for the confirm close modal, will default to { confirmClose: false }
+ * @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 {boolean} enableExtremeOverflowHandling (optional) Whether the modal should enable the extreme overflow handling (may cause issues with keypress registration) or not, will default to false
  * @param {boolean} webkitOnlyOverflowMobileHandling (optional) Whether the modal should only handle overflow for webkit browsers on mobile or should it handle it for all browsers, will default to true
- * @param {D | null} data (optional) The data to pass to the component of the modal. The component needs to use the @Inject(GENERIC_MODAL_DATA) or `data = inject<string>(GENERIC_MODAL_DATA);` (modern syntax) decorator to receive this.
- * @param {IGenericModalStyleConfig} style (optional) The style configuration for the modal, will default to an empty object
+ * @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 IGenericModalConfig<D = undefined, ConfirmComponentData = any, ConfirmComponent extends GenericModal<ConfirmComponentData, undefined> = GenericModal<ConfirmComponentData, undefined>> {
+interface IModalConfig<D> {
     open?: boolean;
     afterClose?: Function;
-    confirmCloseConfig?: IGenericConfirmCloseConfig<ConfirmComponentData, ConfirmComponent>;
+    closeGuard?: ModalCloseGuard;
+    closeGuardOnlyOnCancel?: boolean;
     disableClose?: boolean;
     disableCloseOnBackdropClick?: boolean;
     disableCloseOnNavigation?: boolean;
     enableExtremeOverflowHandling?: boolean;
     webkitOnlyOverflowMobileHandling?: boolean;
     data?: D | null;
-    style?: IGenericModalStyleConfig;
+    style?: IModalStyleConfig;
     bannerText?: string;
     contentClasses?: string;
     contentStyles?: string;
@@ -97,194 +268,65 @@ interface IGenericModalConfig<D = undefined, ConfirmComponentData = any, Confirm
     id?: string;
 }
 
-declare class GenericModalConfig<D = unknown, ConfirmComponentData = any, ConfirmComponent extends GenericModal<ConfirmComponentData, undefined> = GenericModal<ConfirmComponentData, undefined>> {
+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 = unknown> {
     open: boolean;
     afterClose?: Function;
-    confirmCloseConfig?: IGenericConfirmCloseConfig<ConfirmComponentData, ConfirmComponent>;
+    closeGuard?: ModalCloseGuard;
+    closeGuardOnlyOnCancel?: boolean;
     disableClose: boolean;
     disableCloseOnBackdropClick: boolean;
     disableCloseOnNavigation: boolean;
     enableExtremeOverflowHandling?: boolean;
     webkitOnlyOverflowMobileHandling?: boolean;
     data: D | null;
-    style: IGenericModalStyleConfig;
+    style: ModalStyleConfig;
     bannerText: string;
     contentClasses: string;
     contentStyles: string;
     disableConsoleWarnings: boolean;
     disableConsoleInfo: boolean;
     id: string;
-    constructor(config?: IGenericModalConfig<D, ConfirmComponentData, ConfirmComponent>);
-}
-
-declare enum GenericModalState {
-    OPEN = "open",
-    OPENING = "opening",
-    CLOSED = "closed",
-    CLOSING = "closing"
-}
-
-interface IGenericCloseResult<R = any> {
-    data?: R;
-    state: ModalCloseMode;
-}
-
-interface IGenericModalRef<D = any, R = any, C extends GenericModal<D, R> = GenericModal<D, R>> {
-    modalContainer: Type<ModalCore<D, R, C>>;
-    modalContainerRef: ComponentRef<ModalCore<D, R, C>>;
-    modalContainerElement: HTMLElement;
-    parentElement?: HTMLElement;
-    componentRef: ComponentRef<C>;
-    modalState$(): Observable<GenericModalState>;
-    selfIdentifier: {
-        constructor: Function;
-    };
-    modalConfig?: GenericModalConfig<D>;
-    afterClosed(): Observable<IGenericCloseResult<R>>;
-    backdropClick(): Observable<MouseEvent>;
-    open(): void;
-    close: (state: "confirm" | "cancel", result: R | undefined, forceClose: boolean, fromSelf: boolean, from: {
-        constructor: Function;
-    } | undefined) => void;
-}
-
-interface IGenericModalService {
-    viewContainer?: ViewContainerRef;
-    register: (viewContainer: ViewContainerRef, renderer: Renderer2) => void;
-    open: (component: ComponentType<any>, config?: IGenericModalConfig<any>) => GenericModalRef<any, any, any>;
-    close: (self: {
-        constructor: Function;
-    }, fromCloseFunction: boolean | undefined) => void;
-    closeAll: () => void;
-    get: (self: {
-        constructor: Function;
-    }) => GenericModalRef<any, any, any> | ModalCore<any, any, any> | undefined;
-    getSubscribe(self: {
-        constructor: Function;
-    }): Observable<GenericModalRef<any, any, any> | ModalCore<any, any, any> | undefined>;
-    modalsCount: () => number;
-}
-
-declare class GenericModalService implements IGenericModalService {
-    private router;
-    protected injector: Injector;
-    private modals;
-    private modalsSubject;
-    viewContainer?: ViewContainerRef;
-    renderer?: Renderer2;
-    constructor();
-    private createSubscriptions;
-    register(viewContainer: ViewContainerRef, renderer: Renderer2): void;
-    open<D, R, C extends GenericModal<D, R> = GenericModal<D, R>>(component: ComponentType<C>, config?: IGenericModalConfig<D>): GenericModalRef<D, R, C>;
-    close(self: {
-        constructor: Function;
-    }, fromCloseFunction?: boolean | undefined): void;
-    closeAll(onNavigate?: boolean): void;
-    get<D, R, C extends GenericModal<D, R> = GenericModal<D, R>>(self: {
-        constructor: Function;
-    }): GenericModalRef<D, R, C> | ModalCore<D, R, C> | undefined;
-    getSubscribe<D, R, C extends GenericModal<D, R> = GenericModal<D, R>>(self: {
-        constructor: Function;
-    }): Observable<GenericModalRef<D, R, C> | ModalCore<D, R, C> | undefined>;
-    modalsCount(): number;
-    find(self: {
-        constructor: Function;
-    }): boolean;
-    modalRequestedTypeCheck(modal: GenericModalRef | ModalCore | undefined): boolean;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GenericModalService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GenericModalService>;
-}
-
-declare class GenericModalRef<D = unknown, R = any, C extends GenericModal<D, R> = GenericModal<D, R>> implements IGenericModalRef<D, R, C> {
-    private modalService;
-    private _modalContainer;
-    private set modalContainer(value);
-    get modalContainer(): Type<ModalCore<D, R, C>>;
-    private _modalContainerRef;
-    private set modalContainerRef(value);
-    get modalContainerRef(): ComponentRef<ModalCore<D, R, C>>;
-    private _modalContainerElement;
-    private set modalContainerElement(value);
-    get modalContainerElement(): HTMLElement;
-    private _parentElement;
-    private set parentElement(value);
-    get parentElement(): HTMLElement | undefined;
-    private _componentRef;
-    private set componentRef(value);
-    get componentRef(): ComponentRef<C>;
-    private _modalState;
-    private modalState;
-    modalState$(): Observable<GenericModalState>;
-    private getStatus;
-    private _selfIdentifier;
-    private set selfIdentifier(value);
-    get selfIdentifier(): {
-        constructor: Function;
-    };
-    private _modalConfig?;
-    private set modalConfig(value);
-    get modalConfig(): GenericModalConfig<D> | undefined;
-    private backdropClickSubject;
-    backdropClick(): Observable<MouseEvent>;
-    private backdropClicked;
-    private afterCloseSubject;
-    afterClosed(): Observable<IGenericCloseResult<R>>;
-    private afterClose;
-    constructor(componentRef: ComponentRef<C>, selfIdentifier: {
-        constructor: Function;
-    }, modalContainerRef: ComponentRef<ModalCore<D, R, C>>, modalService: GenericModalService, modalConfig?: GenericModalConfig<D>);
-    open(): Promise<void>;
-    close(state?: ModalCloseMode, result?: R | undefined, forceClose?: boolean): void;
-    private handleClose;
-}
-
-declare abstract class GenericModal<D, R> implements OnDestroy {
-    protected genericModalService: GenericModalService;
-    modal?: GenericModalRef<D, R>;
-    protected modalGetSubscription$: Subject<void>;
-    constructor();
-    ngOnDestroy(): void;
-    protected createModalSubscription(): void;
-    protected unsubscribeModalGet(): void;
-    abstract afterModalGet(): void;
-    abstract onDestroy(): void;
-    close(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GenericModal<any, any>, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GenericModal<any, any>>;
+    constructor(config?: IModalConfig<D>);
 }
 
 /**
- * Interface for the Generic Modal Component
- * @param {ComponentRef<any>} componentRef (optional) The component reference (the component that is being displayed in the modal), will default to undefined (for non-dynamic modals)
- * @param {GenericModalConfig} config (optional) The configuration for the modal, will default to default values for the configuration
+ * 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} 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 {boolean} isSwipeableModalActive (required) Whether the swipeable modal is active (open) or not
- * @param {number} animationDuration (required) The duration of the animation (in milliseconds)
- * @param {Subject<MouseEvent>} backdropClickSubject (required) The subject for the backdrop click event, will be used to listen for backdrop clicks
  * @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} closeFunction (optional) The outside function to run when the modal closes (received from the config)
  * @param {Function} close (required) The function to run when the modal closes, will return the result of the modal
- * @param {Function} setHeaderTemplate (required) The function to set the header template of the modal
- * @param {Function} setFooterTemplate (required) The function to set the footer template of the modal
  */
-interface IGenericModalComponenet<D = any, R = any, C extends GenericModal<D, R> = GenericModal<D, R>> extends OnInit, OnDestroy {
+interface IModalComponenet<D, R, C extends IModal<D, R> = IModal<D, R>> extends OnInit, OnDestroy {
     componentRef?: ComponentRef<C>;
-    config?: GenericModalConfig<D>;
+    config?: ModalConfig<D>;
     isOpen: Signal<boolean>;
-    isSwipeableModalActive: Signal<boolean>;
-    animationDuration: number;
-    backdropClickSubject: Subject<MouseEvent>;
     backdropClick: Observable<MouseEvent>;
-    closeFunction?: Function;
     close: (state: ModalCloseMode, result: R | undefined, fromInsideInteraction: boolean, forceClose: boolean) => void;
-    setHeaderTemplate: (template: TemplateRef<any>) => void;
-    setFooterTemplate: (template: TemplateRef<any>) => void;
 }
 
-declare class ModalSwipeable implements OnInit, OnDestroy {
+declare class ModalBottomSheet implements OnInit, OnDestroy {
     readonly headerTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
     readonly footerTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
-    readonly config: _angular_core.InputSignal<GenericModalConfig<any, any, _filip_mazev_modal.GenericModal<any, undefined>> | undefined>;
+    readonly config: _angular_core.InputSignal<ModalConfig<unknown> | undefined>;
     readonly isOpen: _angular_core.InputSignal<boolean>;
     readonly isAnimated: _angular_core.InputSignal<boolean>;
     readonly animationDuration: _angular_core.InputSignal<number>;
@@ -296,7 +338,7 @@ declare class ModalSwipeable implements OnInit, OnDestroy {
     protected downSwipeLimit: number;
     protected isTrackingSwipe: boolean;
     private isTouchActive;
-    private swipeableModalInitiated;
+    private bottomSheetInitiated;
     private cleanupListeners;
     private globalResizeCleanup;
     verticalSwipeTarget?: ElementRef;
@@ -304,42 +346,58 @@ declare class ModalSwipeable implements OnInit, OnDestroy {
     ngOnDestroy(): void;
     private startVerticalSwipeDetection;
     private stopVerticalSwipeDetection;
-    private initSwipeableModalParams;
+    private initBottomSheetModalParams;
     private monitorInputType;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalSwipeable, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalSwipeable, "modal-swipeable", never, { "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>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalBottomSheet, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalBottomSheet, "modal-bottom-sheet", never, { "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 IGenericModalView<D = unknown> {
+/**
+ * Interface for the Modal View
+ * @param D The type of data passed to the modal
+ * @param {InputSignal<TemplateRef<any> | null>} headerTemplate The input signal for the header template of the modal
+ * @param {InputSignal<TemplateRef<any> | 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> {
     headerTemplate: InputSignal<TemplateRef<any> | null>;
     footerTemplate: InputSignal<TemplateRef<any> | null>;
-    config: InputSignal<GenericModalConfig<D> | undefined>;
+    config: InputSignal<ModalConfig<D> | undefined>;
     isOpen: InputSignal<boolean>;
     isAnimated: InputSignal<boolean>;
-    isSwipeableModalActive: InputSignal<boolean>;
+    isBottomSheetModalActive: InputSignal<boolean>;
     animationDuration: InputSignal<number>;
     hasDefaultContentWrapperClass: InputSignal<boolean>;
     hasBanner: InputSignal<boolean>;
     close: OutputEmitterRef<ModalCloseMode | undefined>;
-    swipeableComponents: QueryList<ModalSwipeable>;
+    bottomSheet: QueryList<ModalBottomSheet>;
     modalClasses: Signal<{
         [key: string]: boolean;
     }>;
 }
 
-declare class ModalCentered<D = unknown> implements IGenericModalView<D> {
+declare class ModalCentered<D = unknown> implements IModalView<D> {
     readonly headerTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
     readonly footerTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
-    readonly config: _angular_core.InputSignal<GenericModalConfig<D, any, _filip_mazev_modal.GenericModal<any, undefined>> | undefined>;
+    readonly config: _angular_core.InputSignal<ModalConfig<D> | undefined>;
     readonly isOpen: _angular_core.InputSignal<boolean>;
     readonly isAnimated: _angular_core.InputSignal<boolean>;
-    readonly isSwipeableModalActive: _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>;
-    swipeableComponents: QueryList<ModalSwipeable>;
+    bottomSheet: QueryList<ModalBottomSheet>;
     modalClasses: _angular_core.Signal<{
         'centered-modal-content-wrapper': boolean;
         'centered-modal-default-style': boolean;
@@ -347,21 +405,22 @@ declare class ModalCentered<D = unknown> implements IGenericModalView<D> {
         'centered-modal-animate-out': boolean;
     }>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalCentered<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalCentered<any>, "modal-centered", never, { "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; }; "isSwipeableModalActive": { "alias": "isSwipeableModalActive"; "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>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalCentered<any>, "modal-centered", never, { "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; }; "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 ModalSide<D = unknown> implements IGenericModalView<D> {
+declare class ModalSide<D = unknown> implements IModalView<D> {
+    readonly layout: _angular_core.InputSignal<ModalLayout>;
     readonly headerTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
     readonly footerTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
-    readonly config: _angular_core.InputSignal<GenericModalConfig<D, any, _filip_mazev_modal.GenericModal<any, undefined>> | undefined>;
+    readonly config: _angular_core.InputSignal<ModalConfig<D> | undefined>;
     readonly isOpen: _angular_core.InputSignal<boolean>;
     readonly isAnimated: _angular_core.InputSignal<boolean>;
-    readonly isSwipeableModalActive: _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>;
-    swipeableComponents: QueryList<ModalSwipeable>;
+    bottomSheet: QueryList<ModalBottomSheet>;
     protected renderOpenClass: _angular_core.WritableSignal<boolean>;
     modalClasses: _angular_core.Signal<{
         'side-modal-content-wrapper': boolean;
@@ -374,58 +433,69 @@ declare class ModalSide<D = unknown> implements IGenericModalView<D> {
     }>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalSide<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalSide<any>, "modal-side", never, { "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; }; "isSwipeableModalActive": { "alias": "isSwipeableModalActive"; "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>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalSide<any>, "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; }; "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 ModalCore<D = unknown, R = any, C extends GenericModal<D, R> = GenericModal<D, R>> implements IGenericModalComponenet<D, R, C> {
+declare class ModalCore<D, R, C extends IModal<D, R> = IModal<D, R>> implements IModalComponenet<D, R, C> {
     private modalService;
     private windowDimensionsService;
     private scrollLockService;
     private deviceTypeService;
     readonly afterClose: _angular_core.OutputEmitterRef<void>;
     readonly animationDuration: number;
+    /** The component reference (the component that is being displayed in the modal) */
     componentRef: ComponentRef<C>;
-    config?: GenericModalConfig<D>;
+    /** The configuration for the modal */
+    config?: ModalConfig<D>;
     closeFunction?: Function;
-    backdropClickSubject: Subject<MouseEvent>;
+    private backdropClickSubject;
     backdropClick: Observable<MouseEvent>;
     isOpen: _angular_core.WritableSignal<boolean>;
-    isSwipeableModalActive: _angular_core.WritableSignal<boolean>;
+    effectiveLayout: _angular_core.WritableSignal<ModalLayout>;
+    isCentered: _angular_core.WritableSignal<boolean>;
+    isSide: _angular_core.WritableSignal<boolean>;
     protected headerTemplate: _angular_core.WritableSignal<TemplateRef<any> | null>;
     protected footerTemplate: _angular_core.WritableSignal<TemplateRef<any> | null>;
+    protected isBottomSheetModalActive: _angular_core.WritableSignal<boolean>;
     isAnimated: boolean;
-    isCentered: boolean;
-    isSide: boolean;
     protected hasBanner: boolean;
     protected hasDefaultContentWrapperClass: boolean;
     private isConfirmCloseModalOpen;
-    private isSpecialMobileOverflowHandlingEnabled;
+    private isScrollHandlingEnabled;
     private isScrollDisabled;
+    private _sortedBreakpoints;
     protected windowDimensions: _angular_core.Signal<_filip_mazev_blocks_core.WindowDimensions>;
+    private _currentVcr;
+    set dynamicContainer(vcr: ViewContainerRef | undefined);
     modalContainer?: ElementRef;
+    contentTemplate?: TemplateRef<HTMLElement>;
     sideModalComponents?: QueryList<ModalSide>;
     centeredModalComponents?: QueryList<ModalCentered>;
-    contentTemplate?: TemplateRef<HTMLElement>;
-    dynamicContainer?: ViewContainerRef;
     constructor();
     ngOnInit(): void;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
     private initKeyboardSubscription;
     private initParamsFromConfig;
+    private initBreakpointCache;
     setHeaderTemplate(template: TemplateRef<any>): void;
     setFooterTemplate(template: TemplateRef<any>): void;
+    /**
+     * Closes the modal with the specified state and result.
+     * @param {ModalCloseMode} state The state of the modal close (e.g., 'confirm', 'cancel').
+     * @param {R | undefined} result The result to be returned when the modal closes.
+     * @param {boolean} fromInsideInteraction Whether the close was triggered from inside the modal interaction.
+     * @param {boolean} forceClose Whether to force close the modal, bypassing the close guards.
+    */
     close(state?: ModalCloseMode, result?: R | undefined, fromInsideInteraction?: boolean, forceClose?: boolean): void;
     private handleClose;
     protected onBackdropClick(event: MouseEvent): void;
-    private shouldOpenConfirmCloseModal;
-    private shouldOpenConfirmCloseModalSelfCheck;
-    private handleWindowDimensionChange;
-    private handleSwipeableModalOpened;
-    private handleSwipeableModalClosed;
-    private getSwipeableModal;
-    private resetSwipeableModalPosition;
-    private setSwipeableModalFinishedState;
+    private handleLayout;
+    private handleBottomSheetModalOpened;
+    private handleBottomSheetModalClosed;
+    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>, "modal-core", never, {}, { "afterClose": "afterClose"; }, never, never, true, never>;
 }
@@ -439,58 +509,45 @@ declare class ModalBackdrop {
 }
 
 declare class ModalBanner<D = unknown> {
-    readonly config: _angular_core.InputSignal<GenericModalConfig<D, any, _filip_mazev_modal.GenericModal<any, undefined>> | undefined>;
+    readonly config: _angular_core.InputSignal<ModalConfig<D> | undefined>;
     readonly close: _angular_core.OutputEmitterRef<ModalCloseMode | undefined>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalBanner<any>, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalBanner<any>, "modal-banner", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "close": "close"; }, never, never, true, never>;
 }
 
-declare class GenericModalStyleConfig implements IGenericModalStyleConfig {
-    position: ModalPoistion;
-    handleMobile: boolean;
-    animate: boolean;
-    hasBackdrop: boolean;
-    closeDelay?: number;
-    showCloseButton?: boolean;
-    mobileConfig: IGenericSwipeableModalConfig;
-    contentWrapper: boolean;
-    wrapperClasses: string;
-    wrapperStyles: string;
-    overrideFullHeight: boolean;
-    constructor(config?: IGenericModalStyleConfig);
+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 GENERIC_MODAL_DEFAULT_ANIM_DURATION = 175;
-declare const GENERIC_MODAL_DEFAULT_INTERNAL_ANIM_DURATION = 350;
-declare const GENERIC_MODAL_DEFAULT_ANIM_DURATION_MULTIPLIER_SMALL = 0.65;
-declare const GENERIC_MODAL_DEFAULT_ANIM_DURATION_MULTIPLIER_LARGE = 0.85;
-
-declare const EMPTY_STRING = "";
+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 GENERIC_MODAL_DOWN_SWIPE_LIMIT = 2;
-declare const GENERIC_MODAL_SWIPE_VELOCITY_THRESHOLD = 80;
-
-declare const LOWEST_CHARACTER_CAP = 23;
-declare const LOWER_CHARACTER_CAP = 33;
-declare const MID_CHARACTER_CAP = 49;
-declare const UPPER_CHARACTER_CAP = 60;
-
-declare enum GenericModalErrors {
-    MODAL_DOESNT_MATCH_THE_REQUESTED_TYPES = "The modal doesn't match the requested types.",
-    GENERIC_MODAL_SERVICE_RENDERER_NOT_SET = "ViewContainer and Renderer not set, please set the view container in the constructor of app.module.ts / app.ts (by calling register), before opening a modal",
-    PARENT_MODAL_CANT_BE_THE_SAME_AS_CHILD = "Parent modal cannot be the same as the child modal",
-    PARENT_MODAL_NOT_FOUND = "Parent modal does not exist",
-    PARENT_MODAL_NOT_PROVIDED = "No parent modal provided for multilevel modal"
-}
+declare const MODAL_DOWN_SWIPE_LIMIT = 2;
+declare const MODAL_SWIPE_VELOCITY_THRESHOLD = 80;
 
-declare enum GenericModalWarnings {
-    NO_PARENT_PROVIDED = "No parent modal provided for multilevel modal. Please provide a parent modal or set openAsMultilevel to false.",
-    MULTILEVEL_INLINE_NOT_SUPPORTED = "As of this version, opening a multi-level modal from inline HTML is not possible. Please set openAsMultilevel to false or open your modal through the GenericModalService! Opening modal as normal modal.",
-    MULTILEVEL_NO_PARENT = "Cannot open a multilevel modal with only one modal open. Please open another modal before opening a multilevel modal or set openAsMultilevel to false.",
-    PARENT_MODAL_NOT_SET = "Error setting parent modal. Opening modal as normal modal",
-    CONFIRM_MODAL_NESTING_NOT_SUPPORTED = "Cannot open a confirm modal from within a confirm modal. If you want to allow this behaviour, set bypassSelfCheck to true in the confirmCloseConfig.",
-    FOOTER_DIRECTIVE_OUTSIDE_MODAL = "[ModalFooter] Directive used outside of a GenericModalComponent.",
-    HEADER_DIRECTIVE_OUTSIDE_MODAL = "[ModalHeader] Directive used outside of a GenericModalComponent."
+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 ModalFooterDirective {
@@ -501,7 +558,7 @@ declare class ModalFooterDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ModalFooterDirective, "[modalFooter]", never, {}, {}, never, never, true, never>;
 }
 
-declare const GENERIC_MODAL_DATA: InjectionToken<any>;
+declare const MODAL_DATA: InjectionToken<any>;
 
-export { EMPTY_STRING, GENERIC_MODAL_DATA, GENERIC_MODAL_DEFAULT_ANIM_DURATION, GENERIC_MODAL_DEFAULT_ANIM_DURATION_MULTIPLIER_LARGE, GENERIC_MODAL_DEFAULT_ANIM_DURATION_MULTIPLIER_SMALL, GENERIC_MODAL_DEFAULT_INTERNAL_ANIM_DURATION, GENERIC_MODAL_DOWN_SWIPE_LIMIT, GENERIC_MODAL_SWIPE_VELOCITY_THRESHOLD, GenericModal, GenericModalConfig, GenericModalErrors, GenericModalRef, GenericModalService, GenericModalState, GenericModalStyleConfig, GenericModalWarnings, LOWER_CHARACTER_CAP, LOWEST_CHARACTER_CAP, MID_CHARACTER_CAP, ModalBackdrop, ModalBanner, ModalCentered, ModalCore, ModalFooterDirective, ModalSide, ModalSwipeable, UPPER_CHARACTER_CAP };
-export type { IGenericCloseResult, IGenericConfirmCloseConfig, IGenericModalComponenet, IGenericModalConfig, IGenericModalRef, IGenericModalService, IGenericModalStyleConfig, IGenericModalView, IGenericSwipeableModalConfig, ModalCloseMode, ModalPoistion };
+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, ModalConfig, ModalCore, ModalFooterDirective, ModalRef, ModalService, ModalSide, ModalState, ModalStyleConfig, ModalWarnings };
+export type { BreakpointKey, IBottomSheetModalConfig, IModalCloseResult, IModalComponenet, IModalConfig, IModalRef, IModalService, IModalStyleConfig, IModalView, ModalCloseMode, ModalLayout };