@filip.mazev/modal 0.0.3 → 0.0.5

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

@@ -0,0 +1,510 @@
+import * as _angular_core from '@angular/core';
+import { Type, ComponentRef, OnDestroy, ViewContainerRef, Renderer2, Injector, OnInit, TemplateRef, ElementRef, InputSignal, OutputEmitterRef, QueryList, ChangeDetectorRef, InjectionToken } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { ComponentType } from '@angular/cdk/portal';
+import * as _filip_mazev_modal from '@filip.mazev/modal';
+import { WindowDimensions } from 'common-parts';
+
+type ModalCloseMode = "cancel" | "confirm";
+type ModalPoistion = "center" | "right" | "left";
+
+interface IGenericSwipeableModalConfig {
+    upSwipeLimit?: number;
+    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
+ * @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 {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;
+    animate?: boolean;
+    hasBackdrop?: boolean;
+    closeDelay?: number;
+    showCloseButton?: boolean;
+    mobileConfig?: IGenericSwipeableModalConfig;
+    contentWrapper?: boolean;
+    wrapperClasses?: string;
+    wrapperStyles?: string;
+    overrideFullHeight?: boolean;
+}
+
+/**
+ * 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 {string[]} bannerIcons (optional) The icons 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;
+    bannerIcons?: string[];
+    bypassSelfCheck?: boolean;
+}
+
+/**
+ * IGenericModalConfig<D>, the configuration for the generic 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 {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 {boolean} closeOnSwipeBack (optional) Whether the modal should close when swiped back on mobile devices, will default to false
+ * @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 {IGenericModalStyleConfig} 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} bannerTextAnnotatedString (optional) The annotated string (in bold style, in addition to some text) to display in the banner of the modal, will default to an empty string
+ * @param {string[]} bannerIcons (optional) The icons 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>> {
+    open?: boolean;
+    afterClose?: Function;
+    confirmCloseConfig?: IGenericConfirmCloseConfig<ConfirmComponentData, ConfirmComponent>;
+    disableClose?: boolean;
+    disableCloseOnBackdropClick?: boolean;
+    disableCloseOnNavigation?: boolean;
+    enableExtremeOverflowHandling?: boolean;
+    webkitOnlyOverflowMobileHandling?: boolean;
+    closeOnSwipeBack?: boolean;
+    data?: D | null;
+    style?: IGenericModalStyleConfig;
+    bannerText?: string;
+    bannerTextAnnotatedString?: string;
+    bannerIcons?: string[];
+    contentClasses?: string;
+    contentStyles?: string;
+    disableConsoleWarnings?: boolean;
+    disableConsoleInfo?: boolean;
+    id?: string;
+}
+
+declare class GenericModalConfig<D = unknown, ConfirmComponentData = any, ConfirmComponent extends GenericModal<ConfirmComponentData, undefined> = GenericModal<ConfirmComponentData, undefined>> {
+    open: boolean;
+    afterClose?: Function;
+    confirmCloseConfig?: IGenericConfirmCloseConfig<ConfirmComponentData, ConfirmComponent>;
+    disableClose: boolean;
+    disableCloseOnBackdropClick: boolean;
+    disableCloseOnNavigation: boolean;
+    enableExtremeOverflowHandling?: boolean;
+    webkitOnlyOverflowMobileHandling?: boolean;
+    closeOnSwipeBack: boolean;
+    data: D | null;
+    style: IGenericModalStyleConfig;
+    bannerText: string;
+    bannerTextAnnotatedString: string;
+    bannerIcons: 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<GenericModalComponent<D, R, C>>;
+    modalContainerRef: ComponentRef<GenericModalComponent<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 extends OnDestroy {
+    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> | GenericModalComponent<any, any, any> | undefined;
+    getSubscribe(self: {
+        constructor: Function;
+    }): Observable<GenericModalRef<any, any, any> | GenericModalComponent<any, any, any> | undefined>;
+    modalsCount: () => number;
+}
+
+declare class GenericModalService implements IGenericModalService {
+    private router;
+    protected injector: Injector;
+    private modals;
+    private modalsSubject;
+    viewContainer?: ViewContainerRef;
+    renderer?: Renderer2;
+    private unsubscribe$;
+    constructor();
+    ngOnDestroy(): void;
+    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> | GenericModalComponent<D, R, C> | undefined;
+    getSubscribe<D, R, C extends GenericModal<D, R> = GenericModal<D, R>>(self: {
+        constructor: Function;
+    }): Observable<GenericModalRef<D, R, C> | GenericModalComponent<D, R, C> | undefined>;
+    modalsCount(): number;
+    find(self: {
+        constructor: Function;
+    }): boolean;
+    modalRequestedTypeCheck(modal: GenericModalRef | GenericModalComponent | 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<GenericModalComponent<D, R, C>>;
+    private _modalContainerRef;
+    private set modalContainerRef(value);
+    get modalContainerRef(): ComponentRef<GenericModalComponent<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<GenericModalComponent<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>>;
+}
+
+/**
+ * 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
+ * @param {boolean} isOpen (required) Whether the modal is open or not
+ * @param {number} animationDuration (required) The duration of the animation (in milliseconds)
+ * @param {boolean} isSwipeableModalActive (required) Whether the swipeable modal is active (open) or not
+ * @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} 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 {
+    componentRef?: ComponentRef<C>;
+    config?: GenericModalConfig<D>;
+    isOpen: boolean;
+    animationDuration: number;
+    isSwipeableModalActive: boolean;
+    backdropClickSubject: Subject<MouseEvent>;
+    backdropClick: Observable<MouseEvent>;
+    closeFunction?: Function;
+    close: (state: ModalCloseMode, result: R | undefined, fromInsideInteraction: boolean, forceClose: boolean) => void;
+    setFooterTemplate: (template: TemplateRef<any>) => void;
+}
+
+declare class ModalSwipeable implements OnInit, OnDestroy {
+    readonly footerTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
+    readonly config: _angular_core.InputSignal<GenericModalConfig<any, any, _filip_mazev_modal.GenericModal<any, undefined>> | 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: number;
+    isSwipingVerticallyFinished: boolean;
+    protected isSwipingVertically: boolean;
+    protected downSwipeLimit: number;
+    protected upSwipeLimit: number;
+    protected windowInnerHeight: number;
+    protected isTrackingSwipe: boolean;
+    private isTouchActive;
+    private swipeableModalInitiated;
+    private globalPointerListenerAdded;
+    private touchDetectionUnsubscribe$;
+    verticalSwipeTarget?: ElementRef;
+    modalContent?: ElementRef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private startVerticalSwipeDetection;
+    private stopVerticalSwipeDetection;
+    private initSwipeableModalParams;
+    private monitorInputType;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalSwipeable, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalSwipeable, "modal-swipeable", never, { "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> {
+    footerTemplate: InputSignal<TemplateRef<any> | null>;
+    config: InputSignal<GenericModalConfig<D> | undefined>;
+    isOpen: InputSignal<boolean>;
+    isAnimated: InputSignal<boolean>;
+    isSwipeableModalActive: InputSignal<boolean>;
+    animationDuration: InputSignal<number>;
+    hasDefaultContentWrapperClass: InputSignal<boolean>;
+    hasBanner: InputSignal<boolean>;
+    close: OutputEmitterRef<ModalCloseMode | undefined>;
+    swipeableComponents: QueryList<ModalSwipeable>;
+    get modalClasses(): {
+        [key: string]: boolean;
+    };
+}
+
+declare class ModalCentered<D = unknown> implements IGenericModalView<D> {
+    readonly footerTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
+    readonly config: _angular_core.InputSignal<GenericModalConfig<D, any, _filip_mazev_modal.GenericModal<any, undefined>> | undefined>;
+    readonly isOpen: _angular_core.InputSignal<boolean>;
+    readonly isAnimated: _angular_core.InputSignal<boolean>;
+    readonly isSwipeableModalActive: _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>;
+    get modalClasses(): {
+        [key: string]: boolean;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalCentered<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalCentered<any>, "modal-centered", never, { "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>;
+}
+
+declare class ModalSide<D = unknown> implements IGenericModalView<D> {
+    readonly footerTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
+    readonly config: _angular_core.InputSignal<GenericModalConfig<D, any, _filip_mazev_modal.GenericModal<any, undefined>> | undefined>;
+    readonly isOpen: _angular_core.InputSignal<boolean>;
+    private _innerIsOpen;
+    set innerIsOpen(value: boolean);
+    get innerIsOpen(): boolean;
+    readonly isAnimated: _angular_core.InputSignal<boolean>;
+    readonly isSwipeableModalActive: _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>;
+    constructor();
+    get modalClasses(): {
+        [key: string]: boolean;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalSide<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalSide<any>, "modal-side", never, { "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>;
+}
+
+declare class GenericModalComponent<D = unknown, R = any, C extends GenericModal<D, R> = GenericModal<D, R>> implements IGenericModalComponenet<D, R, C> {
+    private modalService;
+    private windowDimensionService;
+    private scrollLockService;
+    private deviceTypeService;
+    cdr: ChangeDetectorRef;
+    readonly afterClose: _angular_core.OutputEmitterRef<void>;
+    readonly animationDuration: number;
+    componentRef: ComponentRef<C>;
+    config?: GenericModalConfig<D>;
+    closeFunction?: Function;
+    backdropClickSubject: Subject<MouseEvent>;
+    backdropClick: Observable<MouseEvent>;
+    private _isOpen;
+    get isOpen(): boolean;
+    private set isOpen(value);
+    isSwipeableModalActive: boolean;
+    isAnimated: boolean;
+    isCentered: boolean;
+    isSide: boolean;
+    protected hasBanner: boolean;
+    protected hasDefaultContentWrapperClass: boolean;
+    protected footerTemplate: _angular_core.WritableSignal<TemplateRef<any> | null>;
+    private isConfirmCloseModalOpen;
+    private isSpecialMobileOverflowHandlingEnabled;
+    private isScrollDisabled;
+    protected windowDimensions: WindowDimensions;
+    private unsubscribe$;
+    modalContainer?: ElementRef;
+    sideModalComponents?: QueryList<ModalSide>;
+    centeredModalComponents?: QueryList<ModalCentered>;
+    contentTemplate?: TemplateRef<HTMLElement>;
+    dynamicContainer?: ViewContainerRef;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private createSubscriptions;
+    private handleWindowDimensionChange;
+    private initParamsFromConfig;
+    setFooterTemplate(template: TemplateRef<any>): void;
+    close(state?: ModalCloseMode, result?: R | undefined, fromInsideInteraction?: boolean, forceClose?: boolean): void;
+    private handleClose;
+    protected onBackdropClick(event: MouseEvent): void;
+    private shouldOpenConfirmCloseModal;
+    private shouldOpenConfirmCloseModalSelfCheck;
+    private getSwipeableModal;
+    private resetSwipeableModalPosition;
+    private setSwipeableModalFinishedState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GenericModalComponent<any, any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GenericModalComponent<any, any, any>, "generic-modal", never, {}, { "afterClose": "afterClose"; }, never, 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, "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> {
+    readonly config: _angular_core.InputSignal<GenericModalConfig<D, any, _filip_mazev_modal.GenericModal<any, undefined>> | 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 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 GENERIC_MODAL_DOWN_SWIPE_LIMIT = 2;
+declare const GENERIC_MODAL_UP_SWIPE_LIMIT = 1;
+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 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."
+}
+
+declare class ModalFooterDirective {
+    private templateRef;
+    private modal;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalFooterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ModalFooterDirective, "[modalFooter]", never, {}, {}, never, never, true, never>;
+}
+
+declare const GENERIC_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, GENERIC_MODAL_UP_SWIPE_LIMIT, GenericModal, GenericModalComponent, GenericModalConfig, GenericModalErrors, GenericModalRef, GenericModalService, GenericModalState, GenericModalStyleConfig, GenericModalWarnings, LOWER_CHARACTER_CAP, LOWEST_CHARACTER_CAP, MID_CHARACTER_CAP, ModalBackdrop, ModalBanner, ModalCentered, ModalFooterDirective, ModalSide, ModalSwipeable, UPPER_CHARACTER_CAP };
+export type { IGenericCloseResult, IGenericConfirmCloseConfig, IGenericModalComponenet, IGenericModalConfig, IGenericModalRef, IGenericModalService, IGenericModalStyleConfig, IGenericModalView, IGenericSwipeableModalConfig, ModalCloseMode, ModalPoistion };

package/index.d.ts

@@ -1,5 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@filip.mazev/modal" />
-export * from './public-api';

package/lib/classes/generic-modal-config.d.ts

@@ -1,26 +0,0 @@
-import { IGenericConfirmCloseConfig } from "../interfaces/igeneric-confirm-close.interface";
-import { IGenericModalConfig } from "../interfaces/igeneric-modal-config.interface";
-import { IGenericModalStyleConfig } from "../interfaces/igeneric-modal-style-config.interface";
-import { GenericModal } from "./generic-modal";
-export declare class GenericModalConfig<D = unknown, ConfirmComponentData = any, ConfirmComponent extends GenericModal<ConfirmComponentData, undefined> = GenericModal<ConfirmComponentData, undefined>> {
-    open: boolean;
-    afterClose?: Function;
-    confirmCloseConfig?: IGenericConfirmCloseConfig<ConfirmComponentData, ConfirmComponent>;
-    disableClose: boolean;
-    disableCloseOnBackdropClick: boolean;
-    disableCloseOnNavigation: boolean;
-    enableExtremeOverflowHandling?: boolean;
-    webkitOnlyOverflowMobileHandling?: boolean;
-    closeOnSwipeBack: boolean;
-    data: D | null;
-    style: IGenericModalStyleConfig;
-    bannerText: string;
-    bannerTextAnnotatedString: string;
-    bannerIcons: string[];
-    contentClasses: string;
-    contentStyles: string;
-    disableConsoleWarnings: boolean;
-    disableConsoleInfo: boolean;
-    id: string;
-    constructor(config?: IGenericModalConfig<D, ConfirmComponentData, ConfirmComponent>);
-}

package/lib/classes/generic-modal-ref.d.ts

@@ -1,52 +0,0 @@
-import { ComponentRef, Type } from "@angular/core";
-import { Observable } from "rxjs";
-import { GenericModalConfig } from "./generic-modal-config";
-import { GenericModalComponent } from "../components/generic-modal";
-import { GenericModalState } from "../enums/generic-modal-state.enum";
-import { IGenericCloseResult } from "../interfaces/igeneric-close-result.interface";
-import { IGenericModalRef } from "../interfaces/igeneric-modal-ref.interface";
-import { GenericModalService } from "../services/generic-modal.service";
-import { ModalCloseMode } from "../types/modal.types";
-import { GenericModal } from "./generic-modal";
-export 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<GenericModalComponent<D, R, C>>;
-    private _modalContainerRef;
-    private set modalContainerRef(value);
-    get modalContainerRef(): ComponentRef<GenericModalComponent<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<GenericModalComponent<D, R, C>>, modalService: GenericModalService, modalConfig?: GenericModalConfig<D>);
-    open(): Promise<void>;
-    close(state?: ModalCloseMode, result?: R | undefined, forceClose?: boolean): void;
-    private handleClose;
-}

package/lib/classes/generic-modal-style.config.d.ts

@@ -1,17 +0,0 @@
-import { IGenericModalStyleConfig } from "../interfaces/igeneric-modal-style-config.interface";
-import { IGenericSwipeableModalConfig } from "../interfaces/igeneric-swipeable-modal-config";
-import { ModalPoistion } from "../types/modal.types";
-export 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);
-}

package/lib/classes/generic-modal.d.ts

@@ -1,19 +0,0 @@
-import { OnDestroy } from "@angular/core";
-import { GenericModalRef } from "./generic-modal-ref";
-import { Subject } from "rxjs";
-import { GenericModalService } from "../services/generic-modal.service";
-import * as i0 from "@angular/core";
-export 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: i0.ɵɵFactoryDeclaration<GenericModal<any, any>, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<GenericModal<any, any>>;
-}