@koobiq/components 20.4.2 → 21.0.0

package/types/koobiq-components-modal.d.ts

@@ -0,0 +1,666 @@
+import * as _angular_core from '@angular/core';
+import { PipeTransform, TemplateRef, Type, EventEmitter, Injector, InjectionToken, Signal, OnInit, OnChanges, AfterViewInit, OnDestroy, ElementRef, ViewContainerRef, SimpleChanges, ComponentRef, DestroyRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i1 from '@koobiq/components/core';
+import { KbqComponentColors, KbqOverflowShadowState } from '@koobiq/components/core';
+import * as i1$1 from '@angular/cdk/overlay';
+import { OverlayRef, Overlay } from '@angular/cdk/overlay';
+import * as i3$1 from '@koobiq/components/button';
+import { KbqButtonColor } from '@koobiq/components/button';
+import * as _koobiq_components_modal from '@koobiq/components/modal';
+import * as i2 from '@koobiq/components/title';
+import * as i3 from '@koobiq/components/scrollbar';
+import * as i2$1 from '@angular/cdk/a11y';
+import * as i4 from '@koobiq/components/icon';
+import * as i6 from '@angular/common';
+
+declare class CssUnitPipe implements PipeTransform {
+    /** Returns `null` for a value that was never set, so the style binding it feeds is cleared. */
+    transform(value: number | string | null | undefined, defaultUnit?: string): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CssUnitPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CssUnitPipe, "toCssUnit", true>;
+}
+
+type OnClickCallback<T> = (instance: T) => (false | void | {}) | Promise<false | void | {}>;
+type ModalType = 'default' | 'confirm' | 'custom';
+type ConfirmType = 'confirm' | 'success' | 'warn';
+/**
+ * Where focus lands when the dialog is shown.
+ *
+ * `[cdkFocusInitial]` and `autofocus` inside the dialog win over every value but `false`.
+ *
+ * - `first-tabbable` — the first tabbable control, which for a titled dialog is the close button;
+ * - `dialog` — the dialog element itself, so a long scrollable body is read from its start;
+ * - `first-heading` — the dialog title, falling back to the dialog element;
+ * - `false` — nothing is focused, and the caller is responsible for moving focus into the dialog.
+ */
+type KbqModalAutoFocus = 'first-tabbable' | 'dialog' | 'first-heading' | false;
+declare enum ModalSize {
+    Small = "small",
+    Medium = "medium",
+    Large = "large"
+}
+/**
+ * The members of `KbqModalComponent` the composition directives (`kbq-modal-title`,
+ * `kbq-modal-caption`, `kbq-modal-body`, `kbq-modal-footer`) depend on. They are projected into the
+ * dialog, so they inject this token instead of the concrete host component.
+ */
+interface KbqModal {
+    /** Whether the dialog renders a close button in its header. */
+    readonly kbqClosable: Signal<boolean>;
+    /** Palette the composed header binds the close-icon color from. */
+    readonly componentColors: typeof KbqComponentColors;
+    /** Id the dialog element points `aria-labelledby` at. Belongs on the rendered title element. */
+    readonly titleId: string;
+    /** Id the dialog element points `aria-describedby` at. Belongs on the rendered caption element. */
+    readonly captionId: string;
+    /** Scroll-shadow state of the composed body, so the header and footer can render matching shadows. */
+    readonly bodyOverflow: Signal<KbqOverflowShadowState>;
+    /** Emits once the dialog is fully shown. */
+    readonly afterOpen: Observable<void>;
+    /** Runs the cancel flow, exactly as the templated close button does. */
+    onClickCloseBtn(): void;
+    /** Announces that a composed title is rendered, so the dialog can use it as its accessible name. */
+    registerTitle(): void;
+    /** Announces that a composed caption is rendered, so the dialog can use it as its description. */
+    registerCaption(): void;
+    /** Announces that a composed footer is rendered, so the body keeps its normal bottom padding. */
+    registerFooter(): void;
+    /** Publishes the composed body's scroll-shadow state. */
+    setBodyOverflow(state: KbqOverflowShadowState): void;
+}
+/** Injection token exposing the dialog to the directives composed inside it. */
+declare const KBQ_MODAL: InjectionToken<KbqModal>;
+/**
+ * Options `KbqModalService` passes to the dialog it creates. The dialog reads them as the initial
+ * values of its inputs, which is how the imperative path reaches signal inputs at all: a dialog
+ * created by the service has no template bindings, so an input keeps its initial value for life.
+ * Never provided on the declarative path, where the bindings carry the same values.
+ *
+ * @docs-private
+ */
+declare const KBQ_MODAL_OPTIONS: InjectionToken<ModalOptions<any, any>>;
+interface ModalOptions<C = any, R = any> {
+    /** Layout the dialog renders. Default is `'default'`. */
+    kbqModalType?: ModalType;
+    /** Whether the dialog is shown. Managed by the service on the imperative path. */
+    kbqVisible?: boolean;
+    /** Explicit width, overriding the one `kbqSize` implies. A number is read as pixels. */
+    kbqWidth?: number | string;
+    /** Width preset. Default is `ModalSize.Medium` (640px). */
+    kbqSize?: ModalSize;
+    /** Extra class names for the full-screen wrapper around the dialog. */
+    kbqWrapClassName?: string;
+    /** Extra class names for the dialog element itself. */
+    kbqClassName?: string;
+    /** Inline styles for the dialog element. */
+    kbqStyle?: object;
+    /** Heading of the dialog. Also becomes its accessible name. */
+    kbqTitle?: string | TemplateRef<{}>;
+    /** Secondary line under the heading. Also becomes the dialog's accessible description. */
+    kbqCaption?: string | TemplateRef<{}>;
+    /** Body of the dialog: text, a template or a component class. */
+    kbqContent?: string | TemplateRef<{}> | Type<C>;
+    /** The instance of component opened into the dialog. */
+    kbqComponent?: Type<C>;
+    /** Whether the header renders a close button. Default is `true`. */
+    kbqClosable?: boolean;
+    /** Whether the page behind the dialog is dimmed. Default is `true`. */
+    kbqMask?: boolean;
+    /** Whether a click on the dim layer cancels the dialog. Default is `false`. */
+    kbqMaskClosable?: boolean;
+    /** Inline styles for the dim layer. */
+    kbqMaskStyle?: object;
+    /** Inline styles for the body element. */
+    kbqBodyStyle?: object;
+    /** Footer of the dialog: text, a template, or the buttons to render. Default modal ONLY. */
+    kbqFooter?: string | TemplateRef<{}> | IModalButtonOptions<C>[];
+    /** Element or overlay the dialog is rendered into. STATIC — read once, on init. */
+    kbqGetContainer?: HTMLElement | OverlayRef | (() => HTMLElement | OverlayRef) | null;
+    /**
+     * Emitter that mirrors the dialog's own open event. It is subscribed to the dialog, never
+     * substituted for it, so `afterOpen` on the returned `KbqModalRef` keeps working alongside.
+     */
+    kbqAfterOpen?: EventEmitter<void>;
+    /**
+     * Emitter that mirrors the dialog's own close event. It is subscribed to the dialog, never
+     * substituted for it, so `afterClose` on the returned `KbqModalRef` keeps working alongside.
+     */
+    kbqAfterClose?: EventEmitter<R>;
+    /** Whether <kbd>Escape</kbd> cancels the dialog. Default is `true`. */
+    kbqCloseByESC?: boolean;
+    /** Whether focus returns to the trigger when the dialog closes. Default is `true`. */
+    kbqRestoreFocus?: boolean;
+    /** Where focus lands when the dialog is shown. Default is `'first-tabbable'`. */
+    kbqAutoFocus?: KbqModalAutoFocus;
+    /** Accessible name for a dialog rendered without `kbqTitle` — a confirm or a header-less dialog. */
+    kbqAriaLabel?: string;
+    /** Caption of the predefined OK button. The button is not rendered without it. */
+    kbqOkText?: string;
+    /** Color of the predefined OK button. Default is `KbqComponentColors.Contrast`. */
+    kbqOkType?: KbqButtonColor;
+    /** Whether the predefined OK button renders its progress state. */
+    kbqOkLoading?: boolean;
+    /**
+     * Decision handler of the predefined OK button. Returning `false` (or a promise of `false`)
+     * keeps the dialog open; anything else closes it. Pair of the `kbqOnOk` output — bind one.
+     */
+    kbqOkClick?: OnClickCallback<C>;
+    /** Emitter notified when the predefined OK button is activated. Pair of `kbqOkClick` — bind one. */
+    kbqOnOk?: EventEmitter<C>;
+    /** Caption of the predefined Cancel button. The button is not rendered without it. */
+    kbqCancelText?: string;
+    /** Whether the predefined Cancel button renders its progress state. */
+    kbqCancelLoading?: boolean;
+    /**
+     * Decision handler of the predefined Cancel button, the close button, <kbd>Escape</kbd> and the
+     * dim layer. Returning `false` (or a promise of `false`) keeps the dialog open. Pair of the
+     * `kbqOnCancel` output — bind one.
+     */
+    kbqCancelClick?: OnClickCallback<C>;
+    /** Emitter notified when the dialog is cancelled. Pair of `kbqCancelClick` — bind one. */
+    kbqOnCancel?: EventEmitter<C>;
+    /** Data being injected into the child component. */
+    data?: unknown;
+}
+interface IModalOptionsForService<T = any> extends ModalOptions<T> {
+    /**
+     * The injector used to create the component that will be attached.
+     * If specified, it overrides the injector provided by `KbqModalService`.
+     *
+     * Its `DestroyRef` also owns the dialog: the modal is torn down when the injector is destroyed.
+     */
+    injector?: Injector;
+}
+interface IModalButtonOptions<T = any> {
+    label: string;
+    type?: string;
+    shape?: string;
+    ghost?: boolean;
+    size?: string;
+    autoLoading?: boolean;
+    /**
+     * Whether the button is rendered.
+     *
+     * The callable form is re-evaluated on every change-detection pass over the dialog, which is
+     * what lets it track state the dialog knows nothing about — so it must be cheap and free of
+     * side effects. `contentComponentInstance` is passed only when the body is a component.
+     */
+    show?: boolean | ((this: IModalButtonOptions<T>, contentComponentInstance?: T) => boolean);
+    /** Whether the button renders its progress state. Re-evaluated per pass — see {@link IModalButtonOptions.show}. */
+    loading?: boolean | ((this: IModalButtonOptions<T>, contentComponentInstance?: T) => boolean);
+    /** Whether the button is disabled. Re-evaluated per pass — see {@link IModalButtonOptions.show}. */
+    disabled?: boolean | ((this: IModalButtonOptions<T>, contentComponentInstance?: T) => boolean);
+    autoFocus?: boolean;
+    kbqModalMainAction?: boolean;
+    onClick?(this: IModalButtonOptions<T>, contentComponentInstance?: T): (void | {}) | Promise<void | {}>;
+}
+
+/** Phase of the open/close animation the dialog is in, or `null` between phases. */
+type AnimationState = 'enter' | 'leave' | null;
+/** Form a `kbqTitle`/`kbqCaption`/`kbqContent`/`kbqFooter` value took. */
+type KbqModalSlotKind = 'template' | 'component' | 'buttons' | 'string' | 'none';
+declare class KbqModalComponent<T = any, R = any> extends KbqModalRef<T, R> implements KbqModal, OnInit, OnChanges, AfterViewInit, OnDestroy {
+    private overlay;
+    private renderer;
+    private environmentInjector;
+    private elementRef;
+    private viewContainer;
+    private modalControl;
+    private changeDetector;
+    private focusMonitor;
+    private readonly inputModalityDetector;
+    private readonly injector;
+    /** Accessible name for the icon-only close button. */
+    protected readonly a11yLocaleConfiguration: _angular_core.Signal<i1.KbqA11yLocaleConfiguration>;
+    protected readonly document: Document;
+    /**
+     * Options `KbqModalService` passed in, or `null` on the declarative path. Every input below
+     * takes its initial value from here: a service-created dialog carries no template bindings, so
+     * an input it does not bind keeps that initial value for the dialog's whole life.
+     */
+    private readonly options;
+    componentColors: typeof KbqComponentColors;
+    /** Layout the dialog renders. */
+    readonly kbqModalType: _angular_core.InputSignal<ModalType>;
+    /** The instance of component opened into the dialog. */
+    readonly kbqComponent: _angular_core.InputSignal<Type<T> | undefined>;
+    /** Body of the dialog: text, a template or a component class. Falls back to `<ng-content>`. */
+    readonly kbqContent: _angular_core.InputSignal<string | TemplateRef<{}> | Type<T> | undefined>;
+    /** Footer of the dialog: text, a template, or the buttons to render. Default modal ONLY. */
+    readonly kbqFooter: _angular_core.InputSignal<string | TemplateRef<{}> | IModalButtonOptions<T>[] | undefined>;
+    /** Whether the dialog is shown. Two-way bindable as `[(kbqVisible)]`. */
+    readonly kbqVisible: _angular_core.ModelSignal<boolean>;
+    /** Explicit width, overriding the one `kbqSize` implies. A number is read as pixels. */
+    readonly kbqWidth: _angular_core.InputSignal<string | number | undefined>;
+    /** Width preset. */
+    readonly kbqSize: _angular_core.InputSignal<ModalSize>;
+    /** Extra class names for the full-screen wrapper around the dialog. */
+    readonly kbqWrapClassName: _angular_core.InputSignal<string | undefined>;
+    /** Extra class names for the dialog element itself. */
+    readonly kbqClassName: _angular_core.InputSignal<string | undefined>;
+    /** Inline styles for the dialog element. */
+    readonly kbqStyle: _angular_core.InputSignal<object | undefined>;
+    /** Heading of the dialog. Also becomes its accessible name. */
+    readonly kbqTitle: _angular_core.InputSignal<string | TemplateRef<{}> | undefined>;
+    /** Secondary line under the heading. Also becomes the dialog's accessible description. */
+    readonly kbqCaption: _angular_core.InputSignal<string | TemplateRef<{}> | undefined>;
+    /** Whether <kbd>Escape</kbd> cancels the dialog. */
+    readonly kbqCloseByESC: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Where focus lands when the dialog is shown. */
+    readonly kbqAutoFocus: _angular_core.InputSignal<KbqModalAutoFocus>;
+    /** Accessible name for a dialog rendered without `kbqTitle` — a confirm or a header-less dialog. */
+    readonly kbqAriaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Whether the header renders a close button. */
+    readonly kbqClosable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the page behind the dialog is dimmed. */
+    readonly kbqMask: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether a click on the dim layer cancels the dialog. */
+    readonly kbqMaskClosable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Inline styles for the dim layer. */
+    readonly kbqMaskStyle: _angular_core.InputSignal<object | undefined>;
+    /** Inline styles for the body element. */
+    readonly kbqBodyStyle: _angular_core.InputSignal<object | undefined>;
+    readonly kbqAfterOpen: EventEmitter<void>;
+    /** @docs-private */
+    readonly kbqAfterOpenOutput: _angular_core.OutputRef<void>;
+    readonly kbqAfterClose: EventEmitter<R | undefined>;
+    /** @docs-private */
+    readonly kbqAfterCloseOutput: _angular_core.OutputRef<R | undefined>;
+    /** Emitted before the modal begins its closing animation. */
+    readonly kbqBeforeClose: EventEmitter<R | undefined>;
+    /** @docs-private */
+    readonly kbqBeforeCloseOutput: _angular_core.OutputRef<R | undefined>;
+    /** Caption of the predefined OK button. The button is not rendered without it. */
+    readonly kbqOkText: _angular_core.InputSignal<string | undefined>;
+    /** Color of the predefined OK button. */
+    readonly kbqOkType: _angular_core.InputSignal<"theme" | "theme-fade" | "contrast" | "contrast-fade">;
+    /** Whether focus returns to the trigger when the dialog closes. */
+    readonly kbqRestoreFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the predefined OK button renders its progress state. */
+    readonly kbqOkLoading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Decision handler of the predefined OK button. Returning `false` — or a promise of `false` —
+     * keeps the dialog open; anything else closes it. Receives the body component instance when the
+     * body is a component.
+     *
+     * Bind this **or** `(kbqOnOk)`, never both: a handler decides the close itself, so the event has
+     * nothing left to report and is not emitted. Binding both is reported in development mode.
+     */
+    readonly kbqOkClick: _angular_core.InputSignal<OnClickCallback<T> | undefined>;
+    /**
+     * Emits when the predefined OK button is activated. A notification, not a decision — the dialog
+     * closes either way. Bind `[kbqOkClick]` instead to decide whether it closes.
+     */
+    readonly kbqOnOk: EventEmitter<T>;
+    /** @docs-private */
+    readonly kbqOnOkOutput: _angular_core.OutputRef<T>;
+    /** Caption of the predefined Cancel button. The button is not rendered without it. */
+    readonly kbqCancelText: _angular_core.InputSignal<string | undefined>;
+    /** Whether the predefined Cancel button renders its progress state. */
+    readonly kbqCancelLoading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Decision handler of the predefined Cancel button, the close button, <kbd>Escape</kbd> and the
+     * dim layer. Returning `false` — or a promise of `false` — keeps the dialog open.
+     *
+     * Bind this **or** `(kbqOnCancel)`, never both — see `kbqOkClick`.
+     */
+    readonly kbqCancelClick: _angular_core.InputSignal<OnClickCallback<T> | undefined>;
+    /**
+     * Emits when the dialog is cancelled, by any of the controls `kbqCancelClick` covers. A
+     * notification, not a decision. Bind `[kbqCancelClick]` instead to decide whether it closes.
+     */
+    readonly kbqOnCancel: EventEmitter<T>;
+    /** @docs-private */
+    readonly kbqOnCancelOutput: _angular_core.OutputRef<T>;
+    readonly modalContainer: _angular_core.Signal<ElementRef<any>>;
+    readonly bodyContainer: _angular_core.Signal<ViewContainerRef>;
+    private readonly scrollbarViewports;
+    private readonly trapFocus;
+    private readonly uniqueId;
+    /** Id of the element that names the dialog. Rendered on the title of a composed modal too. */
+    readonly titleId: string;
+    /** Id of the element that describes the dialog. Rendered on the caption of a composed modal too. */
+    readonly captionId: string;
+    /**
+     * Scroll-shadow state published by `KbqModalBody` when the modal content is composed
+     * manually (`kbq-modal-title`/`kbq-modal-body`/`kbq-modal-footer`), so the header/footer
+     * can render matching shadows without a direct template reference between them.
+     *
+     * @docs-private
+     */
+    readonly bodyOverflow: _angular_core.WritableSignal<KbqOverflowShadowState>;
+    get afterOpen(): Observable<void>;
+    /** Observable alias for `kbqBeforeClose` */
+    get beforeClose(): Observable<R | undefined>;
+    get afterClose(): Observable<R | undefined>;
+    get hidden(): boolean;
+    /**
+     * Footer buttons with their defaults filled in. `kbqFooter` reports what was bound; this is what
+     * the template renders, so the input is never written back over.
+     */
+    protected readonly footer: _angular_core.Signal<string | TemplateRef<{}> | IModalButtonOptions<T>[] | undefined>;
+    /** @docs-private */
+    protected readonly titleKind: _angular_core.Signal<KbqModalSlotKind>;
+    /** @docs-private */
+    protected readonly captionKind: _angular_core.Signal<KbqModalSlotKind>;
+    /** @docs-private */
+    protected readonly contentKind: _angular_core.Signal<KbqModalSlotKind>;
+    /** @docs-private */
+    protected readonly footerKind: _angular_core.Signal<KbqModalSlotKind>;
+    /** Whether the dialog renders a footer — a predefined button is enough, `kbqFooter` is not required. */
+    protected get hasFooter(): boolean;
+    /** Id of the element naming the dialog, or `null` when there is no title to point at. */
+    protected get ariaLabelledBy(): string | null;
+    /** Accessible name for a dialog with no title. Never rendered next to `aria-labelledby`. */
+    protected get ariaLabel(): string | null;
+    /** Id of the caption describing the dialog, or `null` when no caption is rendered. */
+    protected get ariaDescribedBy(): string | null;
+    /**
+     * Whether this dialog is covered by another one. `aria-modal` only hides the page behind the
+     * topmost dialog, so every dialog below it is taken out of the accessibility tree and the tab
+     * order explicitly.
+     */
+    protected get inert(): boolean;
+    /** Phase of the open/close animation, which the class list and the hidden state follow. */
+    private readonly animationPhase;
+    /** Full set of classes for the dialog element. */
+    protected readonly containerClasses: _angular_core.Signal<string>;
+    /**
+     * Phase of the dim layer's animation. Follows the dialog's own phase, except while
+     * `KbqModalControlService` fades the layer of a covered dialog out on its own.
+     */
+    private readonly maskPhase;
+    /**
+     * Whether the dim layer is actually painted: the input, overridden while another dialog covers
+     * this one. Seeded from the input so re-binding `[kbqMask]` still takes effect.
+     *
+     * The override exists because `KbqModalControlService` turns the layer of the dialogs underneath
+     * a newly opened one off and back on. That orchestration belongs in the dialog, keyed on
+     * `KbqModalControlService.topVisibleModal()` the way `inert` already is.
+     */
+    private readonly maskEnabled;
+    /** Classes for the dim layer. */
+    protected readonly maskAnimationClasses: _angular_core.Signal<string>;
+    /**
+     * Progress state the predefined buttons actually render: the input, overridden while a handler's
+     * returned promise is pending. Seeded from the input so re-binding it still takes effect.
+     */
+    private readonly okLoading;
+    private readonly cancelLoading;
+    /** @docs-private */
+    protected loading(triggerType: 'ok' | 'cancel'): boolean;
+    private focusedElementBeforeOpen;
+    private previouslyFocusedElementOrigin;
+    private monitoredContainer;
+    private focusMonitorSubscription;
+    /** Whether a `kbq-modal-title` is composed inside the dialog body. */
+    private composedTitle;
+    /** Whether a `kbq-modal-caption` is composed inside the dialog body. */
+    private composedCaption;
+    /** Whether a `kbq-modal-footer` is composed inside the dialog body. */
+    private composedFooter;
+    private viewInitialized;
+    /** Visibility the open/close flow has already run for. See `syncVisibleState`. */
+    private handledVisible;
+    private contentComponentRef;
+    private animationState;
+    private container;
+    /** Element or overlay the dialog is rendered into. Read once, on init. */
+    readonly kbqGetContainer: _angular_core.InputSignal<HTMLElement | OverlayRef | (() => HTMLElement | OverlayRef) | null>;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    open(): void;
+    /**
+     * Starts the closing animation and resolves the `afterClose` contract with `result`.
+     *
+     * Closing an already closed dialog is a no-op: `afterClose` emits once per actual transition.
+     */
+    close(result?: R): void;
+    destroy(result?: R): void;
+    markForCheck(): void;
+    triggerOk(): void;
+    triggerCancel(): void;
+    getInstance(): KbqModalComponent;
+    getContentComponentRef(): ComponentRef<T>;
+    getContentComponent(): T;
+    getElement(): HTMLElement;
+    /** Announces that a `kbq-modal-title` is composed inside the dialog. @docs-private */
+    registerTitle(): void;
+    /** Announces that a `kbq-modal-caption` is composed inside the dialog. @docs-private */
+    registerCaption(): void;
+    /** Announces that a `kbq-modal-footer` is composed inside the dialog. @docs-private */
+    registerFooter(): void;
+    /** Publishes the composed body's scroll-shadow state. @docs-private */
+    setBodyOverflow(state: KbqOverflowShadowState): void;
+    /**
+     * Drives the dim layer's animation on its own, which is what lets `KbqModalControlService` fade
+     * out the layer of a dialog another one has covered.
+     *
+     * @docs-private
+     */
+    animateMaskTo(state: AnimationState): void;
+    /**
+     * Turns the dim layer off or back on without touching `kbqMask`, so a dialog covered by another
+     * one stops painting its own layer. See `maskEnabled`.
+     *
+     * @docs-private
+     */
+    setMaskEnabled(enabled: boolean): void;
+    /** @docs-private */
+    protected isMaskEnabled(): boolean;
+    onClickCloseBtn(): void;
+    /** @docs-private */
+    protected onClickMask($event: MouseEvent): void;
+    /** @docs-private */
+    protected isModalType(type: ModalType): boolean;
+    /** @docs-private */
+    protected onKeyDown(event: KeyboardEvent): void;
+    /** @docs-private */
+    protected onClickOkCancel(type: 'ok' | 'cancel'): void;
+    /** @docs-private */
+    protected handleCloseResult(triggerType: 'ok' | 'cancel', canClose: (doClose: boolean | void | {}) => boolean): void;
+    /**
+     * Lookup a button's property, if the prop is a function, call & then return the result, otherwise, return itself.
+     *
+     * @docs-private
+     */
+    protected getButtonCallableProp(options: IModalButtonOptions<T>, prop: string): {};
+    /**
+     * On kbqFooter's modal button click.
+     *
+     * @docs-private
+     */
+    protected onButtonClick(button: IModalButtonOptions<T>): void;
+    /** Whether anything is rendered that can name the dialog. */
+    private hasTitle;
+    /** Whether anything is rendered that can describe the dialog. */
+    private hasCaption;
+    private handleVisibleStateChange;
+    /**
+     * Remembers the element and the input modality to restore focus to. Both entry paths run
+     * through here, so a declarative `<kbq-modal [(kbqVisible)]>` restores focus like a
+     * service-created one.
+     */
+    private captureFocus;
+    /**
+     * Registers the dialog element with `FocusMonitor` so focus inside it carries an origin. The
+     * registration is torn down on the first focus event and, failing that, on destroy — a dialog
+     * focus never reaches would otherwise stay in the root-provided monitor forever.
+     */
+    private monitorContainer;
+    private restoreFocus;
+    /** Moves focus into the dialog once the shown state has been rendered. */
+    private focusOnShow;
+    /**
+     * Initial focus policy. An explicit `[cdkFocusInitial]`/`autofocus` inside the dialog always
+     * wins; otherwise `kbqAutoFocus` decides. The dialog element itself is the last resort, so a
+     * modal without a single tabbable control still takes focus off the trigger behind it.
+     */
+    private focusInitialElement;
+    private changeVisibleFromInside;
+    /**
+     * Runs the open/close flow for a visibility that arrived through a binding. A value this dialog
+     * set itself has already been handled, so it is skipped.
+     */
+    private syncVisibleState;
+    private changeAnimationState;
+    /**
+     * Runs the enter/leave animation and settles when it is really over: on `animationend`, as soon
+     * as the dialog is rendered when animations are disabled (`kbqAnimationsDisabled`), and on a
+     * timer when neither arrives.
+     */
+    private animateTo;
+    private formatModalButtons;
+    /**
+     * Create a component dynamically but not attach to any View
+     * (this action will be executed when bodyContainer is ready)
+     *
+     * @param component Component class
+     */
+    private createDynamicComponent;
+    /** Locks the body scroll while any dialog is shown, and releases it once none is. */
+    private changeBodyOverflow;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqModalComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqModalComponent<any, any>, "kbq-modal", never, { "kbqModalType": { "alias": "kbqModalType"; "required": false; "isSignal": true; }; "kbqComponent": { "alias": "kbqComponent"; "required": false; "isSignal": true; }; "kbqContent": { "alias": "kbqContent"; "required": false; "isSignal": true; }; "kbqFooter": { "alias": "kbqFooter"; "required": false; "isSignal": true; }; "kbqVisible": { "alias": "kbqVisible"; "required": false; "isSignal": true; }; "kbqWidth": { "alias": "kbqWidth"; "required": false; "isSignal": true; }; "kbqSize": { "alias": "kbqSize"; "required": false; "isSignal": true; }; "kbqWrapClassName": { "alias": "kbqWrapClassName"; "required": false; "isSignal": true; }; "kbqClassName": { "alias": "kbqClassName"; "required": false; "isSignal": true; }; "kbqStyle": { "alias": "kbqStyle"; "required": false; "isSignal": true; }; "kbqTitle": { "alias": "kbqTitle"; "required": false; "isSignal": true; }; "kbqCaption": { "alias": "kbqCaption"; "required": false; "isSignal": true; }; "kbqCloseByESC": { "alias": "kbqCloseByESC"; "required": false; "isSignal": true; }; "kbqAutoFocus": { "alias": "kbqAutoFocus"; "required": false; "isSignal": true; }; "kbqAriaLabel": { "alias": "kbqAriaLabel"; "required": false; "isSignal": true; }; "kbqClosable": { "alias": "kbqClosable"; "required": false; "isSignal": true; }; "kbqMask": { "alias": "kbqMask"; "required": false; "isSignal": true; }; "kbqMaskClosable": { "alias": "kbqMaskClosable"; "required": false; "isSignal": true; }; "kbqMaskStyle": { "alias": "kbqMaskStyle"; "required": false; "isSignal": true; }; "kbqBodyStyle": { "alias": "kbqBodyStyle"; "required": false; "isSignal": true; }; "kbqOkText": { "alias": "kbqOkText"; "required": false; "isSignal": true; }; "kbqOkType": { "alias": "kbqOkType"; "required": false; "isSignal": true; }; "kbqRestoreFocus": { "alias": "kbqRestoreFocus"; "required": false; "isSignal": true; }; "kbqOkLoading": { "alias": "kbqOkLoading"; "required": false; "isSignal": true; }; "kbqOkClick": { "alias": "kbqOkClick"; "required": false; "isSignal": true; }; "kbqCancelText": { "alias": "kbqCancelText"; "required": false; "isSignal": true; }; "kbqCancelLoading": { "alias": "kbqCancelLoading"; "required": false; "isSignal": true; }; "kbqCancelClick": { "alias": "kbqCancelClick"; "required": false; "isSignal": true; }; "kbqGetContainer": { "alias": "kbqGetContainer"; "required": false; "isSignal": true; }; }, { "kbqVisible": "kbqVisibleChange"; "kbqAfterOpenOutput": "kbqAfterOpen"; "kbqAfterCloseOutput": "kbqAfterClose"; "kbqBeforeCloseOutput": "kbqBeforeClose"; "kbqOnOkOutput": "kbqOnOk"; "kbqOnCancelOutput": "kbqOnCancel"; }, never, ["*"], true, [{ directive: typeof i1.KbqLocaleOverridesDirective; inputs: { "kbqLocaleOverrides": "localeOverrides"; }; outputs: {}; }]>;
+}
+
+/**
+ * API class that public to users to handle the modal instance.
+ * KbqModalRef is aim to avoid accessing to the modal instance directly by users.
+ */
+declare abstract class KbqModalRef<C = any, R = unknown> {
+    abstract afterOpen: Observable<void>;
+    abstract beforeClose: Observable<R | undefined>;
+    abstract afterClose: Observable<R | undefined>;
+    abstract open(): void;
+    abstract close(result?: R): void;
+    abstract destroy(result?: R): void;
+    /**
+     * Runs the OK flow exactly as the predefined OK button does: the `kbqOkClick` handler when one
+     * is bound, the `kbqOnOk` emitter otherwise.
+     */
+    abstract triggerOk(): void;
+    /** Runs the cancel flow exactly as the predefined Cancel button does. */
+    abstract triggerCancel(): void;
+    /**
+     * Return the component instance of kbqContent when specify kbqContent as a Component
+     * Note: this method may return undefined if the Component has not ready yet.
+     * (it only available after Modal's ngOnInit)
+     */
+    abstract getContentComponent(): C;
+    /**
+     * Get the dom element of this Modal
+     */
+    abstract getElement(): HTMLElement;
+    /**
+     * Get the instance of the Modal itself
+     */
+    abstract getInstance(): KbqModalComponent;
+    /**
+     * Call markForCheck for change detector
+     */
+    abstract markForCheck(): any;
+}
+
+declare class KbqModalTitle {
+    protected modal: _koobiq_components_modal.KbqModal;
+    /** Accessible name for the icon-only close button. */
+    protected readonly a11yLocaleConfiguration: _angular_core.Signal<i1.KbqA11yLocaleConfiguration>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqModalTitle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqModalTitle, "[kbq-modal-title], kbq-modal-title, [kbqModalTitle]", never, {}, {}, never, ["*", "kbq-modal-caption, [kbq-modal-caption], [kbqModalCaption]", "[kbqModalTitleActions]"], true, [{ directive: typeof i1.KbqLocaleOverridesDirective; inputs: { "kbqLocaleOverrides": "localeOverrides"; }; outputs: {}; }]>;
+}
+/**
+ * Caption of a manually composed modal (`kbqComponent`). Projected into the header rendered by
+ * `KbqModalTitle`, below the title, and clamped to two lines. The resulting markup matches the
+ * header of a modal created via `KbqModalService.create`.
+ */
+declare class KbqModalCaption {
+    protected readonly modal: _koobiq_components_modal.KbqModal;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqModalCaption, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqModalCaption, "[kbq-modal-caption], kbq-modal-caption, [kbqModalCaption]", never, {}, {}, never, ["*"], true, [{ directive: typeof i2.KbqTitleDirective; inputs: {}; outputs: {}; }]>;
+}
+/**
+ * Scrollable body of a manually composed modal (`kbqComponent`). Publishes its scroll-shadow
+ * state onto the modal instance so a sibling `KbqModalTitle`/`KbqModalFooter` can render the
+ * matching shadow, since they have no direct template reference to this element.
+ */
+declare class KbqModalBody {
+    private readonly modal;
+    private readonly overflowContainer;
+    private readonly scrollbarViewport;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqModalBody, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqModalBody, "[kbq-modal-body], kbq-modal-body, [kbqModalBody]", never, {}, {}, never, never, true, [{ directive: typeof i1.KbqOverflowShadowContainer; inputs: {}; outputs: {}; }, { directive: typeof i3.KbqScrollbarViewport; inputs: {}; outputs: {}; }]>;
+}
+declare class KbqModalFooter {
+    protected modal: _koobiq_components_modal.KbqModal;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqModalFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqModalFooter, "[kbq-modal-footer], kbq-modal-footer, [kbqModalFooter]", never, {}, {}, never, never, true, never>;
+}
+declare class KbqModalMainAction {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqModalMainAction, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqModalMainAction, "[kbq-modal-main-action]", never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqModalModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqModalModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqModalModule, never, [typeof i1$1.OverlayModule, typeof i2$1.A11yModule, typeof i3$1.KbqButtonModule, typeof i4.KbqIconModule, typeof i2.KbqTitleModule, typeof i6.NgTemplateOutlet, typeof KbqModalComponent, typeof KbqModalTitle, typeof KbqModalCaption, typeof KbqModalBody, typeof KbqModalFooter, typeof CssUnitPipe, typeof KbqModalMainAction], [typeof KbqModalComponent, typeof KbqModalTitle, typeof KbqModalCaption, typeof KbqModalBody, typeof KbqModalFooter, typeof KbqModalMainAction]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqModalModule>;
+}
+
+/** Injection token that can be used to access the data that was passed in to a modal. */
+declare const KBQ_MODAL_DATA: InjectionToken<unknown>;
+/**
+ * A builder used for managing service creating modals
+ *
+ * @docs-private
+ */
+declare class ModalBuilderForService {
+    private readonly overlay;
+    readonly options: IModalOptionsForService;
+    private readonly injector;
+    private modalRef;
+    private overlayRef;
+    private detachFromOpener?;
+    constructor(overlay: Overlay, options: IModalOptionsForService | undefined, injector: Injector, 
+    /** Lifetime of the caller. The dialog is destroyed with it. */
+    openerDestroyRef?: DestroyRef | null);
+    getInstance(): KbqModalComponent | null;
+    destroyModal(): void;
+    /**
+     * Mirrors the caller's emitters onto the dialog's own outputs. The option values themselves
+     * reach the dialog through `KBQ_MODAL_OPTIONS`, as the initial values of its inputs — a dialog
+     * created by the service has no template bindings to carry them.
+     */
+    private mirrorEmitters;
+    private createModal;
+}
+declare class KbqModalService {
+    private readonly overlay;
+    private readonly modalControl;
+    private injector;
+    get openModals(): KbqModalRef[];
+    get afterAllClose(): Observable<void>;
+    closeAll(): void;
+    /**
+     * Opens a dialog. Its lifetime is bound to `options.injector` — the caller's injector when one
+     * is passed, the root environment injector otherwise — so destroying the opener closes it.
+     */
+    create<C, R = unknown>(options?: IModalOptionsForService<C>): KbqModalRef<C, R>;
+    confirm<C, R = unknown>(options?: IModalOptionsForService<C>, confirmType?: ConfirmType): KbqModalRef<C, R>;
+    open<C, R = unknown>(options?: IModalOptionsForService<C>): KbqModalRef<C, R>;
+    success<C, R = unknown>(options?: IModalOptionsForService<C>): KbqModalRef<C, R>;
+    /** Opens a confirm dialog styled for a destructive action — the `warn` confirm type. */
+    delete<C, R = unknown>(options?: IModalOptionsForService<C>): KbqModalRef<C, R>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqModalService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KbqModalService>;
+}
+
+export { CssUnitPipe, KBQ_MODAL, KBQ_MODAL_DATA, KBQ_MODAL_OPTIONS, KbqModalBody, KbqModalCaption, KbqModalComponent, KbqModalFooter, KbqModalMainAction, KbqModalModule, KbqModalRef, KbqModalService, KbqModalTitle, ModalBuilderForService, ModalSize };
+export type { AnimationState, ConfirmType, IModalButtonOptions, IModalOptionsForService, KbqModal, KbqModalAutoFocus, ModalOptions, ModalType, OnClickCallback };