import * as i0 from '@angular/core';
import { AfterViewInit, OnDestroy, ElementRef, InjectionToken, OnInit, TemplateRef, Injector, ChangeDetectorRef, Renderer2, NgZone, EnvironmentInjector, OnChanges, EventEmitter, SimpleChanges } from '@angular/core';
import { ActivatedRoute, Router, Routes, Params, Route, Data, CanDeactivateFn } from '@angular/router';
import { KirbyAnimation, ThemeColor, PlatformService } from '@kirbydesign/designsystem/helpers';
import { Observable } from 'rxjs';
import { ModalController as ModalController$1, AnimationBuilder, IonContent } from '@ionic/angular/standalone';
import { WindowRef } from '@kirbydesign/designsystem/types';
import { OverlayEventDetail as OverlayEventDetail$1 } from '@ionic/core/components';
import { TranslationService, ResizeObserverService } from '@kirbydesign/designsystem/shared';

interface OverlayEventDetail<T = any> {
    data?: T;
    role?: string;
}
interface Overlay {
    dismiss: (data?: any) => Promise<boolean>;
    onWillDismiss: Promise<OverlayEventDetail>;
    onDidDismiss: Promise<OverlayEventDetail>;
    isDismissing?: boolean;
}
interface ModalRouteActivation {
    route: ActivatedRoute;
    isNewModal: boolean;
}
declare abstract class Modal {
    didPresent: Promise<void>;
    willClose: Promise<void>;
    close: (data?: any) => Promise<void>;
    scrollToTop: (scrollDuration?: KirbyAnimation.Duration) => void;
    scrollToBottom: (scrollDuration?: KirbyAnimation.Duration) => void;
    scrollDisabled: boolean;
    canDismiss: ShowAlertCallback;
    focusTitle?: () => void;
}
/**
 * WARNING: This is for internal use only and should not be used outside of Kirby.
 */
declare enum ModalElementType {
    PAGE_PROGRESS = 0,
    FOOTER = 1,
    TITLE = 2
}
/**
 * WARNING: This is for internal use only and should not be used outside of Kirby.
 */
declare abstract class ModalElementsAdvertiser {
    addModalElement: (type: ModalElementType, elementRef: ElementRef<HTMLElement>) => void;
    removeModalElement: (type: ModalElementType, elementRef: ElementRef<HTMLElement>) => void;
}
/**
 * WARNING: This is for internal use only and should not be used outside of Kirby.
 */
declare abstract class ModalElementComponent implements AfterViewInit, OnDestroy {
    private modalElementType;
    private elementRef;
    private modalElementsAdvertiser;
    private get isContainedInModal();
    constructor(modalElementType: ModalElementType, elementRef: ElementRef<HTMLElement>, modalElementsAdvertiser: ModalElementsAdvertiser);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalElementComponent, [null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalElementComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

interface ActionSheetItem {
    id: string;
    text: string;
}

interface ActionSheetConfig {
    header?: string;
    subheader?: string;
    items: Array<ActionSheetItem>;
    cancelButtonText?: string;
}

interface AlertConfig {
    title: string | Observable<string>;
    message?: string | Observable<string>;
    cancelBtn?: string | Observable<string>;
    icon?: {
        name: string;
        themeColor?: string;
    };
    okBtn?: string | Observable<string> | {
        text: string | Observable<string>;
        isDestructive: boolean;
    };
}

declare class ModalNavigationService {
    private router;
    private route;
    constructor(router: Router, route: ActivatedRoute);
    isModalRoute(url: string): boolean;
    private getCurrentActivatedRoute;
    private getModalRoutes;
    private getModuleRootPath;
    private getCurrentRoutePaths;
    private getRoutePathsWithoutChildSegments;
    private findChildRouteForUrl;
    private pathContainsChildRouteWithUrlParams;
    private getRoutePaths;
    private getRoutePath;
    private getModalRoutePath;
    private getModalRoutePaths;
    private isNewModalWindow;
    private navigationEndListener$;
    private waitForCurrentThenGetNavigationEndStream;
    private modalRouteActivatedFor;
    private modalRouteDeactivatedFor;
    private modalRouteSetContainsPath;
    getModalNavigation(routeConfig: Routes[], moduleRootRoutePath?: string): Promise<{
        activated$: Observable<ModalRouteActivation>;
        deactivated$: Observable<boolean>;
    }>;
    navigateToModal(path: string | string[], queryParams?: Params): Promise<boolean>;
    navigateWithinModal(relativePath: string, queryParams?: Params): Promise<boolean>;
    navigateOutOfModalOutlet(): Promise<boolean>;
    private getBackdropRoute;
    handleBrowserBackButton(modal: HTMLIonModalElement): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalNavigationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ModalNavigationService>;
}

declare class DrawerSupplementaryAction {
    iconName: string;
    action: Function;
}

type ModalFlavor = 'modal' | 'drawer' | 'compact';
type ModalSize = 'small' | 'medium' | 'large' | 'full-height';
type ShowAlertCallback = () => boolean | AlertConfig | Promise<boolean | AlertConfig>;
interface ModalConfig {
    collapseTitle?: boolean;
    component?: any;
    size?: ModalSize;
    customHeight?: string;
    modalRoute?: ActivatedRoute;
    siblingModalRouteActivated$?: Observable<ActivatedRoute>;
    flavor?: ModalFlavor;
    componentProps?: {
        [key: string]: any;
    };
    canDismiss?: ShowAlertCallback;
    drawerSupplementaryAction?: DrawerSupplementaryAction;
    interactWithBackground?: boolean;
    cssClass?: string | string[];
    htmlAttributes?: {
        [key: string]: any;
    };
}
/**
 * Here we extend Data and Route from Angular to create a covariant type ModalEnabledRoutes.
 * This can be used in place of the Routes type when configuring route-based modals in the array
 * of routes passed to RouterModule in applications.
 */
type RoutedModalConfig = Omit<ModalConfig, 'component'>;
interface ModalConfigRouteData extends Data {
    modalConfig?: RoutedModalConfig;
}
interface ModalEnabledRoute extends Route {
    data?: ModalConfigRouteData;
    children?: ModalEnabledRoutes;
}
type ModalEnabledRoutes = ModalEnabledRoute[];

declare const COMPONENT_PROPS: InjectionToken<string>;

declare class AlertComponent implements AfterViewInit {
    private elementRef;
    private windowRef;
    readonly BLUR_WRAPPER_DELAY_IN_MS = 50;
    private alertWrapper;
    private scrollY;
    title$: Observable<string>;
    set title(title: string | Observable<string>);
    message$: Observable<string>;
    set message(message: string | Observable<string>);
    iconName: string;
    iconThemeColor: ThemeColor | `${ThemeColor}`;
    okBtn$: Observable<string>;
    set okBtn(okBtn: string | Observable<string>);
    okBtnIsDestructive: boolean;
    cancelBtn$: Observable<string>;
    set cancelBtn(cancelBtn: string | Observable<string>);
    constructor(elementRef: ElementRef<HTMLElement>, windowRef: WindowRef);
    ngAfterViewInit(): void;
    onFocusChange(): void;
    onCancel(): void;
    onOk(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AlertComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AlertComponent, "kirby-alert", never, { "title": { "alias": "title"; "required": false; }; "message": { "alias": "message"; "required": false; }; "iconName": { "alias": "iconName"; "required": false; }; "iconThemeColor": { "alias": "iconThemeColor"; "required": false; }; "okBtn": { "alias": "okBtn"; "required": false; }; "okBtnIsDestructive": { "alias": "okBtnIsDestructive"; "required": false; }; "cancelBtn": { "alias": "cancelBtn"; "required": false; }; }, {}, never, never, true, never>;
}

declare class AlertHelper {
    private ionicModalController;
    constructor(ionicModalController: ModalController$1);
    showAlert(config: AlertConfig): Promise<Overlay>;
    private getComponentProps;
    private getOkBtn;
    getOkBtnIsDestructive(config: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<AlertHelper, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AlertHelper>;
}

declare class CanDismissHelper {
    private alertHelper;
    constructor(alertHelper: AlertHelper);
    getCanDismissCallback(callback: ShowAlertCallback): () => Promise<boolean>;
    showAlert(config: AlertConfig): Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CanDismissHelper, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CanDismissHelper>;
}

declare class ModalWrapperComponent implements Modal, AfterViewInit, OnInit, OnDestroy, ModalElementsAdvertiser {
    private changeDetector;
    private injector;
    private elementRef;
    private renderer;
    private zone;
    private resizeObserverService;
    private windowRef;
    private platform;
    private canDismissHelper;
    private environmentInjector;
    translations: TranslationService;
    get _hasCollapsibleTitle(): boolean;
    static readonly KEYBOARD_HIDE_DELAY_IN_MS = 100;
    scrollY: number;
    private readonly VIEWPORT_RESIZE_DEBOUNCE_TIME;
    set scrollDisabled(disabled: boolean);
    set canDismiss(callback: ShowAlertCallback);
    config: ModalConfig;
    content: TemplateRef<any>;
    componentPropsInjector: Injector;
    modalWrapperInjector: Injector;
    templateRef: TemplateRef<any>;
    private toolbarButtonsQuery;
    private ionContent;
    private ionContentElement;
    private ionHeaderElement;
    private ionToolbarElement;
    private ionTitleElement;
    private routerOutlet;
    private _contentTitleElement;
    get contentTitleElement(): ElementRef<HTMLElement>;
    private keyboardVisible;
    private toolbarButtons;
    private delayedClose;
    private delayedCloseTimeoutId;
    private initialViewportHeight;
    private viewportResized;
    private ionModalElement?;
    private ionModalDialog?;
    private readonly ionModalDidPresent;
    readonly didPresent: Promise<void>;
    private readonly ionModalWillDismiss;
    readonly willClose: Promise<void>;
    private viewportResize;
    private viewportResize$;
    private mutationObserverUnobserveFn;
    private _intersectionObserver;
    private get intersectionObserver();
    scrollEventsEnabled: boolean;
    isContentScrolled: boolean;
    private destroy$;
    get _isDrawer(): boolean;
    willClose$: Observable<void>;
    private modalElementsMoverDelegate;
    constructor(changeDetector: ChangeDetectorRef, injector: Injector, elementRef: ElementRef<HTMLElement>, renderer: Renderer2, zone: NgZone, resizeObserverService: ResizeObserverService, windowRef: WindowRef, platform: PlatformService, canDismissHelper: CanDismissHelper, environmentInjector: EnvironmentInjector, translations: TranslationService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private _currentFooter;
    private set currentFooter(value);
    private get currentFooter();
    addModalElement(type: ModalElementType, modalElement: ElementRef<HTMLElement>): void;
    removeModalElement(type: ModalElementType, modalElement: ElementRef<HTMLElement>): void;
    private initializeResizeModalToModalWrapper;
    private initializeSizing;
    private initializeModalRoute;
    private onSiblingModalRouteActivated;
    private patchScrollElementSize;
    private observeModalFullHeight;
    private getIonModalWrapperElement;
    private observeHeaderResize;
    private listenForIonModalDidPresent;
    private listenForIonModalWillDismiss;
    private listenForScroll;
    private observeTitleContentChanges;
    private setAriaLabelFromTitleContent;
    private setAriaLabel;
    private focusTitleOnDidPresent;
    focusTitle(): void;
    scrollToTop(scrollDuration?: KirbyAnimation.Duration): void;
    scrollToBottom(scrollDuration?: KirbyAnimation.Duration): void;
    close(data?: any): Promise<void>;
    onFocusChange(): void;
    _onKeyboardShow(keyboardHeight: number): void;
    _onKeyboardHide(): void;
    private toggleContentMaxHeight;
    private setKeyboardVisibility;
    private getKeyboardOverlap;
    private setCssVar;
    private toggleCssClass;
    private setKeyboardOverlap;
    onHeaderTouchStart(event: TouchEvent): void;
    _onWindowResize(): void;
    private setViewportHeight;
    private observeViewportResize;
    private onViewportResize;
    blurActiveElement(): void;
    private createModalWrapperIntersectionObserver;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalWrapperComponent, "kirby-modal-wrapper", never, { "scrollDisabled": { "alias": "scrollDisabled"; "required": false; }; "config": { "alias": "config"; "required": false; }; "content": { "alias": "content"; "required": false; }; }, {}, ["templateRef"], never, true, never>;
}

declare class ModalCompactWrapperComponent implements Modal, OnInit {
    private injector;
    private elementRef;
    private windowRef;
    private canDismissHelper;
    private renderer;
    config: ModalConfig;
    content: TemplateRef<any>;
    scrollY: number;
    scrollDisabled: boolean;
    componentPropsInjector: Injector;
    private ionModalElement;
    private readonly ionModalDidPresent;
    private readonly ionModalWillDismiss;
    readonly didPresent: Promise<void>;
    readonly willClose: Promise<void>;
    constructor(injector: Injector, elementRef: ElementRef<HTMLElement>, windowRef: WindowRef, canDismissHelper: CanDismissHelper, renderer: Renderer2);
    ngOnInit(): void;
    private listenForIonModalDidPresent;
    private listenForIonModalWillDismiss;
    private setAriaLabel;
    close(data?: any): Promise<void>;
    set canDismiss(callback: ShowAlertCallback);
    scrollToTop: (_?: any) => void;
    scrollToBottom: (_?: any) => void;
    onFocusChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalCompactWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalCompactWrapperComponent, "kirby-modal-compact-wrapper", never, { "config": { "alias": "config"; "required": false; }; "content": { "alias": "content"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ActionSheetHelper {
    private ionicModalController;
    constructor(ionicModalController: ModalController$1);
    showActionSheet(config: ActionSheetConfig): Promise<Overlay>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActionSheetHelper, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ActionSheetHelper>;
}

declare class ModalAnimationBuilderService {
    private platform;
    constructor(platform: PlatformService);
    private readonly easingEnter;
    private readonly easingLeave;
    private readonly duration;
    private readonly SwipeToCloseDefaults;
    enterAnimation(currentBackdrop?: HTMLIonBackdropElement): AnimationBuilder;
    leaveAnimation(currentBackdrop?: HTMLIonBackdropElement): AnimationBuilder;
    private createEnterAnimation;
    private createLeaveAnimation;
    /**
     * Gets the root context of a shadow dom element
     * On newer browsers this will be the shadowRoot,
     * but for older browser this may just be the
     * element itself.
     *
     * Useful for whenever you need to explicitly
     * do "myElement.shadowRoot!.querySelector(...)".
     */
    private getElementRoot;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalAnimationBuilderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ModalAnimationBuilderService>;
}

declare class ModalHelper {
    private ionicModalController;
    private modalAnimationBuilder;
    private modalNavigationService;
    private windowRef;
    private canDismissHelper;
    constructor(ionicModalController: ModalController$1, modalAnimationBuilder: ModalAnimationBuilderService, modalNavigationService: ModalNavigationService, windowRef: WindowRef, canDismissHelper: CanDismissHelper);
    private isModalOpening;
    showModalWindow(config: ModalConfig): Promise<Overlay>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalHelper, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ModalHelper>;
}

declare class ModalController implements OnDestroy {
    private modalHelper;
    private actionSheetHelper;
    private alertHelper;
    private modalNavigationService;
    private routeConfig;
    private overlays;
    private readonly noOverlayRegisteredErrorMessage;
    private destroy$;
    constructor(modalHelper: ModalHelper, actionSheetHelper: ActionSheetHelper, alertHelper: AlertHelper, modalNavigationService: ModalNavigationService, routeConfig: Routes[]);
    initialize(moduleRootRoutePath?: string): Promise<void>;
    private onModalRouteActivated;
    private onModalRouteDeactivated;
    showModal(config: ModalConfig, onClose?: (data?: any) => void): Promise<void>;
    navigateToModal(path: string | string[], queryParams?: Params): Promise<boolean>;
    navigateWithinModal(relativePath: string, queryParams?: Params): Promise<boolean>;
    private showModalRoute;
    showActionSheet(config: ActionSheetConfig, onClose?: (data?: any) => void): Promise<void>;
    showAlert(config: AlertConfig, onClose?: (result: boolean) => void): Promise<void>;
    private showAndRegisterOverlay;
    hideTopmost(data?: any): Promise<boolean>;
    hideAll(): Promise<void>;
    getTopMost(): Overlay | null;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalController, [null, null, null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ModalController>;
}

declare const CanDismissModalGuard: CanDeactivateFn<unknown>;

declare class ModalComponent implements OnChanges, OnInit {
    private canDismissHelper;
    private modalNavigationService;
    private windowRef;
    private elementRef;
    modalElement: ElementRef<HTMLIonModalElement>;
    ionContent: IonContent;
    template: TemplateRef<unknown>;
    isOpen: boolean;
    trigger: string;
    size: ModalSize;
    scrollDisabled: boolean;
    set canDismiss(canDismiss: ShowAlertCallback | boolean);
    collapseTitle: boolean;
    customHeight: string;
    flavor: ModalFlavor;
    drawerSupplementaryAction?: DrawerSupplementaryAction;
    interactWithBackground: boolean;
    willPresent: EventEmitter<CustomEvent<OverlayEventDetail$1<any>>>;
    didPresent: EventEmitter<CustomEvent<OverlayEventDetail$1<any>>>;
    didDismiss: EventEmitter<CustomEvent<OverlayEventDetail$1<any>>>;
    willDismiss: EventEmitter<CustomEvent<OverlayEventDetail$1<any>>>;
    /**
     * We populate the ModalConfig with defaults here. This ensures that we can
     * guard for `if (key in this._config)` and only update the config when any of these
     * inputs change.
     */
    _config: ModalConfig;
    _canDismiss: ShowAlertCallback | boolean;
    constructor(canDismissHelper: CanDismissHelper, modalNavigationService: ModalNavigationService, windowRef: WindowRef, elementRef: ElementRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    scrollToTop(scrollDuration?: KirbyAnimation.Duration): void;
    scrollToBottom(scrollDuration?: KirbyAnimation.Duration): void;
    _onWillPresent(event: CustomEvent<OverlayEventDetail$1>): void;
    _onDidPresent(event: CustomEvent<OverlayEventDetail$1>): void;
    _onWillDismiss(event: CustomEvent<OverlayEventDetail$1>): void;
    _onDidDismiss(event: CustomEvent<OverlayEventDetail$1>): void;
    private updateModalConfigOnChange;
    private forwardAriaLabel;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "kirby-modal", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; "size": { "alias": "size"; "required": false; }; "scrollDisabled": { "alias": "scrollDisabled"; "required": false; }; "canDismiss": { "alias": "canDismiss"; "required": false; }; "collapseTitle": { "alias": "collapseTitle"; "required": false; }; "customHeight": { "alias": "customHeight"; "required": false; }; "flavor": { "alias": "flavor"; "required": false; }; "drawerSupplementaryAction": { "alias": "drawerSupplementaryAction"; "required": false; }; "interactWithBackground": { "alias": "interactWithBackground"; "required": false; }; }, { "willPresent": "willPresent"; "didPresent": "didPresent"; "didDismiss": "didDismiss"; "willDismiss": "willDismiss"; }, ["template"], never, true, never>;
}

declare class ModalFooterComponent extends ModalElementComponent {
    snapToKeyboard: boolean;
    type: 'inline' | 'fixed';
    themeColor: 'white' | 'light';
    get _cssClass(): ("inline" | "fixed" | "white" | "light")[];
    constructor(elementRef: ElementRef<HTMLElement>, modalElementsAdvertiser: ModalElementsAdvertiser);
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalFooterComponent, [null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalFooterComponent, "kirby-modal-footer", never, { "snapToKeyboard": { "alias": "snapToKeyboard"; "required": false; }; "type": { "alias": "type"; "required": false; }; "themeColor": { "alias": "themeColor"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ActionSheetComponent {
    cancelButtonText: string;
    hideCancel: boolean;
    disabled: boolean;
    header: string;
    subheader: string;
    items: Array<ActionSheetItem>;
    cancel: EventEmitter<any>;
    itemSelect: EventEmitter<ActionSheetItem>;
    constructor();
    onItemSelect(selection: ActionSheetItem): void;
    onCancel(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActionSheetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActionSheetComponent, "kirby-action-sheet", never, { "cancelButtonText": { "alias": "cancelButtonText"; "required": false; }; "hideCancel": { "alias": "hideCancel"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "header": { "alias": "header"; "required": false; }; "subheader": { "alias": "subheader"; "required": false; }; "items": { "alias": "items"; "required": false; }; }, { "cancel": "cancel"; "itemSelect": "itemSelect"; }, never, never, true, never>;
}

export { ActionSheetComponent, ActionSheetHelper, AlertComponent, AlertHelper, COMPONENT_PROPS, CanDismissHelper, CanDismissModalGuard, DrawerSupplementaryAction, Modal, ModalCompactWrapperComponent, ModalComponent, ModalController, ModalElementComponent, ModalElementType, ModalElementsAdvertiser, ModalFooterComponent, ModalHelper, ModalNavigationService, ModalWrapperComponent };
export type { ActionSheetConfig, ActionSheetItem, AlertConfig, ModalConfig, ModalEnabledRoutes, ModalFlavor, ModalRouteActivation, ModalSize, Overlay, OverlayEventDetail, RoutedModalConfig, ShowAlertCallback };
//# sourceMappingURL=kirbydesign-designsystem-modal.d.ts.map