@malva-ui/core 0.1.12 → 0.1.14

package/types/malva-ui-core-dialog.d.ts

@@ -0,0 +1,597 @@
+import { MlvDirection, MlvTone } from '@malva-ui/cdk/utils';
+import * as i0 from '@angular/core';
+import { Signal, InjectionToken, Injector, TemplateRef, Type, ElementRef } from '@angular/core';
+import { MlvOverlayInitialFocus } from '@malva-ui/cdk/overlay';
+import { DialogRef } from '@angular/cdk/dialog';
+import { Observable } from 'rxjs';
+import * as _malva_ui_core_dialog from '@malva-ui/core/dialog';
+import * as _malva_ui_i18n from '@malva-ui/i18n';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { DefaultExport, Route } from '@angular/router';
+
+/** Lifecycle of the surface animation driven by `MlvDialogRef.animationState`. */
+type MlvDialogAnimationState = 'enter' | 'idle' | 'leave';
+/**
+ * Handle returned by `MlvDialogService.open()` (and exposed to content through
+ * DI and the template context) for controlling a dialog and receiving its result.
+ *
+ * Wraps the CDK `DialogRef` the engine creates. `close()` plays the surface's
+ * leave animation first — `animationState` flips to `'leave'`, `<mlv-dialog>`
+ * adds `.mlv-dialog--leave`, and its `animationend` calls back here — and only
+ * then disposes the CDK dialog, so `afterClosed()` emits after the animation.
+ *
+ * @typeParam R - Result type emitted by `afterClosed()`.
+ * @typeParam D - Type of `data`.
+ */
+declare class MlvDialogRef<R = unknown, D = unknown> {
+    /** @private The CDK reference this handle controls. */
+    private readonly _cdkRef;
+    /** Payload from `MlvDialogConfig.data`. */
+    readonly data: D;
+    /** The consumer's configuration this dialog was opened with. */
+    readonly config: Readonly<MlvDialogConfig<D>>;
+    /** Id of the dialog container element (CDK-generated unless `config.id` was set). */
+    readonly id: string;
+    /** Drives the surface's `--enter` / `--leave` classes. */
+    readonly animationState: Signal<MlvDialogAnimationState>;
+    /** @private Writable side of {@link animationState}. */
+    private readonly _animationState;
+    /** @private Emits once, synchronously, at the start of `close()`. */
+    private readonly _beforeClose;
+    /** @private Guards `close()` against re-entry and late calls. */
+    private _closeStarted;
+    /**
+     * @private Set once the CDK dialog has actually closed. From then on the ref
+     * is inert: a late `animationend` from the torn-down surface must not move
+     * `animationState` or re-enter the close path.
+     */
+    private _disposed;
+    /** @private Result captured by the first `close()` call. */
+    private _result;
+    /** @private Fallback timer that disposes when `animationend` never arrives. */
+    private _leaveTimer;
+    constructor(
+    /** @private The CDK reference this handle controls. */
+    _cdkRef: DialogRef<R>, config: Readonly<MlvDialogConfig<D>>);
+    /**
+     * Closes the dialog: emits `beforeClose()`, plays the leave animation, then
+     * disposes and emits `result` on `afterClosed()`. Idempotent.
+     *
+     * @param result - Value forwarded to `afterClosed()` subscribers.
+     */
+    close(result?: R): void;
+    /** Emits once with the close result after the dialog is disposed, then completes. */
+    afterClosed(): Observable<R | undefined>;
+    /** Emits and completes synchronously when `close()` is called, before the leave animation. */
+    beforeClose(): Observable<void>;
+    /**
+     * Keydown events that reach this dialog. The CDK delivers a keydown only to
+     * the topmost overlay with keydown observers, so a dialog (or a select /
+     * combobox popup) opened on top of this one receives Escape instead of it.
+     * Pair with `closeOnEscape: false` to run a close guard yourself.
+     */
+    keydownEvents(): Observable<KeyboardEvent>;
+    /** Backdrop clicks on this dialog. Pair with `closeOnBackdrop: false` to run a close guard yourself. */
+    backdropClick(): Observable<MouseEvent>;
+    /** Updates the overlay pane's width and/or height. */
+    updateSize(width?: string | number, height?: string | number): this;
+    /** Adds class(es) to the overlay pane. */
+    addPanelClass(classes: string | string[]): this;
+    /** Removes class(es) from the overlay pane. */
+    removePanelClass(classes: string | string[]): this;
+    /**
+     * @internal Called by `<mlv-dialog>` when its own CSS animation ends:
+     * the enter animation settles to `'idle'`, the leave animation disposes.
+     */
+    _onSurfaceAnimationEnd(): void;
+    /**
+     * @internal Registers `id` as a label of the dialog. Used by
+     * `mlv-dialog-header` so the visible title becomes the accessible name.
+     * `ariaLabelledBy` from the config is queued first by the CDK container and
+     * therefore still wins; `ariaLabel` suppresses `aria-labelledby` entirely.
+     */
+    _labelBy(id: string): void;
+    /** @internal Reverses {@link _labelBy} when the header is destroyed. */
+    _unlabelBy(id: string): void;
+    /** @private The CDK container while the dialog is open, `null` once disposed. */
+    private _container;
+    /** @private Disposes the CDK dialog with the captured result. Safe to call twice. */
+    private _finishClose;
+    /** @private Cancels the fallback timer if it is pending. */
+    private _clearLeaveTimer;
+}
+
+/** Built-in size preset names. Any other string resolves through `DIALOG_SIZE_PRESETS`. */
+type MlvDialogSizePreset = 's' | 'm' | 'l' | 'fullscreen';
+/** Explicit dialog dimensions. Numbers are pixels; strings are any CSS length. */
+interface MlvDialogSizeConfig {
+    /** Width of the overlay pane. */
+    width?: string | number;
+    /** Height of the overlay pane. Unset lets the content decide. */
+    height?: string | number;
+    /** Smallest width the pane may shrink to. */
+    minWidth?: string | number;
+    /** Smallest height the pane may shrink to. */
+    minHeight?: string | number;
+    /** Largest width the pane may grow to — keep it viewport-relative for small screens. */
+    maxWidth?: string | number;
+    /** Largest height the pane may grow to; the body scrolls once the content exceeds it. */
+    maxHeight?: string | number;
+}
+/** Map of preset name → dimensions, provided through `DIALOG_SIZE_PRESETS`. */
+type MlvDialogSizePresets = Record<string, MlvDialogSizeConfig>;
+/**
+ * A preset name or explicit dimensions.
+ *
+ * The built-in preset names get editor completion; any other registered preset
+ * name still works — `(string & {})` keeps the union open without collapsing it
+ * to bare `string`.
+ */
+type MlvDialogSize = MlvDialogSizePreset | (string & {}) | MlvDialogSizeConfig;
+/** `'confirm'` drops the header/footer borders and hides the close button. */
+type MlvDialogAppearance = 'default' | 'confirm';
+/** ARIA role of the dialog container. */
+type MlvDialogRole = 'dialog' | 'alertdialog';
+/** Static focus restoration target understood by the Angular CDK dialog. */
+type MlvDialogRestoreFocusTarget = boolean | string | HTMLElement;
+/**
+ * Resolves a focus restoration target immediately before dialog disposal.
+ *
+ * Use this when the correct target depends on responsive or other UI state
+ * that may change while the dialog is open. Returning `true` restores the
+ * captured opener only when it is still connected; returning a disconnected
+ * element disables restoration for that close.
+ */
+type MlvDialogRestoreFocusResolver = () => MlvDialogRestoreFocusTarget;
+/**
+ * Focus restoration policy applied when a dialog closes.
+ *
+ * Static boolean, selector, and element values retain the Angular CDK's
+ * behavior. A resolver is evaluated at actual disposal so a composed overlay
+ * can choose from current UI state rather than freezing its target at open.
+ */
+type MlvDialogRestoreFocus = MlvDialogRestoreFocusTarget | MlvDialogRestoreFocusResolver;
+/** Registered dialog size presets. Override to add or change presets app-wide. */
+declare const DIALOG_SIZE_PRESETS: InjectionToken<MlvDialogSizePresets>;
+/**
+ * Per-open configuration for `MlvDialogService.open()` and
+ * `ng-template[mlvDialog]`'s `mlvDialogOptions`.
+ *
+ * Everything CDK-related is mapped by the service; `title`, `closable` and
+ * `appearance` are Malva-only and are read by `mlv-dialog` /
+ * `mlv-dialog-header` through `DIALOG_CONFIG`.
+ */
+interface MlvDialogConfig<D = unknown> {
+    /** Preset name or explicit dimensions. Defaults to `'m'`. */
+    size?: MlvDialogSize;
+    /**
+     * Text direction applied to the dialog pane.
+     *
+     * The pane is portaled to `<body>`, so it never inherits a `[dir]` scope the
+     * opener sits in. Defaults to the direction resolved from the focused
+     * element at open time, then the global direction.
+     */
+    direction?: MlvDirection;
+    /** Surface appearance. Defaults to `'default'`. */
+    appearance?: MlvDialogAppearance;
+    /**
+     * Plain-text title. Used by string content, as the `mlv-dialog-header`
+     * fallback when it has neither a `title` input nor projected content, and
+     * for the accessible name.
+     */
+    title?: string;
+    /** Default for `mlv-dialog-header`'s close button. Defaults to `true`. */
+    closable?: boolean;
+    /** Extra class(es) on the overlay pane (`.mlv-dialog-pane`). */
+    panelClass?: string | string[];
+    /** Extra class(es) on the backdrop (`.mlv-dialog-backdrop`). */
+    backdropClass?: string | string[];
+    /** Whether a backdrop is rendered. Defaults to `true`. */
+    hasBackdrop?: boolean;
+    /** Whether a backdrop click closes the dialog. Defaults to `true`. */
+    closeOnBackdrop?: boolean;
+    /** Whether Escape closes the dialog. Defaults to `true`. */
+    closeOnEscape?: boolean;
+    /** Whether browser history navigation closes the dialog. Defaults to `true`. */
+    closeOnNavigation?: boolean;
+    /** Where focus lands once the dialog is open. Defaults to `'auto'`. */
+    initialFocus?: MlvOverlayInitialFocus;
+    /** Static target or disposal-time resolver. Defaults to `true` (the captured opener). */
+    restoreFocus?: MlvDialogRestoreFocus;
+    /** ARIA role. Defaults to `'dialog'`. */
+    role?: MlvDialogRole;
+    /** Accessible name when no visible title labels the dialog. */
+    ariaLabel?: string;
+    /** Id of an element that labels the dialog. Wins over `ariaLabel` and the header title. */
+    ariaLabelledBy?: string;
+    /** Id of an element that describes the dialog. */
+    ariaDescribedBy?: string;
+    /** Payload exposed as `MlvDialogRef.data`, `DIALOG_DATA` and the template context's `data`. */
+    data?: D;
+    /** Parent injector for the content. Defaults to the root injector. */
+    injector?: Injector;
+    /** Id of the dialog container. Generated when omitted. */
+    id?: string;
+}
+/**
+ * Data passed through `MlvDialogConfig.data`, injectable by component content.
+ * This is Angular CDK's `DIALOG_DATA` token re-exported under the same name.
+ */
+declare const DIALOG_DATA: InjectionToken<unknown>;
+/** The consumer's `MlvDialogConfig` for the current dialog, injectable by content and parts. */
+declare const DIALOG_CONFIG: InjectionToken<Readonly<MlvDialogConfig<unknown>>>;
+/**
+ * Template context for `TemplateRef` content (`let-dialog`, `let-data="data"`).
+ * The ref is both the implicit value and the named `ref`.
+ */
+interface MlvDialogTemplateContext<R = unknown, D = unknown> {
+    /** The dialog's ref, as the implicit value (`let-dialog`). */
+    $implicit: MlvDialogRef<R, D>;
+    /** The same ref under a name (`let-dialog="ref"`). */
+    ref: MlvDialogRef<R, D>;
+    /** Payload from `MlvDialogConfig.data` (`let-data="data"`). */
+    data: D;
+    /** The configuration this dialog was opened with (`let-config="config"`). */
+    config: Readonly<MlvDialogConfig<D>>;
+}
+/** Content accepted by `MlvDialogService.open()`. Strings render as escaped text. */
+type MlvDialogContent<R = unknown, D = unknown> = string | TemplateRef<MlvDialogTemplateContext<R, D>> | Type<unknown>;
+
+/**
+ * The dialog surface — root of every dialog's content, whether the dialog was
+ * opened from a template, a component, a string, `confirm()`, or a route.
+ *
+ * Projects its children (`mlv-dialog-header`, `mlv-dialog-body`,
+ * `mlv-dialog-footer`, anything else) and mirrors the ref's animation state as
+ * `--enter` / `--leave` so the global dialog keyframes run on it. Consumer
+ * `class="…"` lands here; `MlvDialogConfig.panelClass` styles the overlay pane.
+ */
+declare class MlvDialog {
+    /** @protected The dialog this surface belongs to. */
+    protected readonly _ref: _malva_ui_core_dialog.MlvDialogRef<unknown, unknown>;
+    /** @protected Per-open configuration; `appearance` drives the confirm modifier. */
+    protected readonly _config: Readonly<_malva_ui_core_dialog.MlvDialogConfig<unknown>>;
+    /** @private Host element, used to ignore `animationend` bubbling from descendants. */
+    private readonly _host;
+    /** @protected Hands the surface's own animation end to the ref (enter → idle, leave → dispose). */
+    protected _onAnimationEnd(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDialog, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvDialog, "mlv-dialog", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Header row of a dialog: the title and the close button.
+ *
+ * Use it as an element (`<mlv-dialog-header title="…" />`) or as an attribute
+ * on a container (`<div mlvDialogHeader>`). Never put it on a heading — project
+ * the heading instead: `<mlv-dialog-header><h3>Edit user</h3></mlv-dialog-header>`.
+ *
+ * Title precedence: `title` input → projected content → `MlvDialogConfig.title`.
+ * Close button: `closable` input → `MlvDialogConfig.closable` → `true`, and
+ * always off when `MlvDialogConfig.appearance` is `'confirm'`.
+ *
+ * The title element carries `id="<dialogId>-title-<n>"` — unique per header, so
+ * two headers in one dialog never collide — and is registered as the
+ * dialog's label, so the visible title is the accessible name unless the
+ * config sets `ariaLabelledBy` / `ariaLabel`. The label follows the rendered
+ * title: the id is registered as soon as the title element gains text — an
+ * asynchronous title (`[title]="user()?.name"`, a projected heading fed by a
+ * resolver) is picked up — and removed again when it loses it. A header that
+ * renders no title at all (used only to host the close button) registers
+ * nothing — labelling the dialog with an empty element would leave it without
+ * an accessible name.
+ */
+declare class MlvDialogHeader {
+    /** Plain-text title rendered as `<h2>`. Wins over projected content and the config title. */
+    readonly title: i0.InputSignal<string | undefined>;
+    /**
+     * Whether the close button is rendered. Unset → `MlvDialogConfig.closable`
+     * → `true`. Ignored (always hidden) when the dialog `appearance` is `'confirm'`.
+     */
+    readonly closable: i0.InputSignalWithTransform<boolean | undefined, BooleanInput>;
+    /** @protected The dialog this header labels and closes. */
+    protected readonly _ref: _malva_ui_core_dialog.MlvDialogRef<unknown, unknown>;
+    /** @protected Per-open configuration (title / closable / appearance fallbacks). */
+    protected readonly _config: Readonly<_malva_ui_core_dialog.MlvDialogConfig<unknown>>;
+    /** @protected i18n strings — `closeDialog` labels the X. */
+    protected readonly _i18n: i0.Signal<_malva_ui_i18n.MlvDialogI18n>;
+    /**
+     * @protected Id of the title element; the ref registers it as the dialog
+     * label. Per instance, not per dialog — two headers in the same dialog (a
+     * sticky bar plus a scrolled-away one, say) must not collide on one id.
+     */
+    protected readonly _titleId: string;
+    /** @protected Config title used as the `<ng-content>` fallback. */
+    protected readonly _configTitle: string | undefined;
+    /** @protected Resolved close-button visibility (see class docs for precedence). */
+    protected readonly _closable: i0.Signal<boolean>;
+    /**
+     * @protected The rendered title element, in either branch. Its text decides
+     * whether the dialog is labelled by this header.
+     */
+    protected readonly _titleEl: i0.Signal<ElementRef<HTMLElement> | undefined>;
+    /** @private Whether {@link _titleId} is currently registered as the dialog's label. */
+    private _labelled;
+    /** @private Set on destroy so a queued render callback never runs on a torn-down view. */
+    private _destroyed;
+    constructor();
+    /**
+     * @private Keeps the dialog's label in sync with the rendered title: the id
+     * is registered as soon as the title element has text and removed again when
+     * it loses it, so a title that only arrives asynchronously still names the
+     * dialog. An empty title element would still win the CDK's `aria-labelledby`
+     * queue and leave the dialog with an empty accessible name (an axe
+     * `aria-dialog-name` violation), so a header without any title — no `title`
+     * input, no projected content, no `config.title` — registers nothing.
+     */
+    private _syncLabel;
+    /** @protected Closes the dialog with no result, as the X always does. */
+    protected _close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDialogHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvDialogHeader, "mlv-dialog-header, [mlvDialogHeader]", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Scrollable body of a dialog. Wraps its content in `mlv-scrollbar` (padding
+ * sits inside the scroll viewport so focus rings are never clipped).
+ */
+declare class MlvDialogBody {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDialogBody, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvDialogBody, "mlv-dialog-body, [mlvDialogBody]", never, {}, {}, never, ["*"], true, never>;
+}
+
+/** Horizontal alignment of a dialog footer's actions. */
+type MlvDialogFooterAlign = 'start' | 'end' | 'center' | 'between';
+/**
+ * Footer row of a dialog: a wrapping flex row of actions, end-aligned by
+ * default. Replaces the toolbar + spacer boilerplate.
+ */
+declare class MlvDialogFooter {
+    /** Where the actions sit: `'start'`, `'end'` (default), `'center'`, or `'between'`. */
+    readonly align: i0.InputSignal<MlvDialogFooterAlign>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDialogFooter, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvDialogFooter, "mlv-dialog-footer, [mlvDialogFooter]", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Closes the enclosing dialog when the host is clicked, optionally with a
+ * result: `<button mlvDialogClose>` closes with `undefined`,
+ * `<button mlvDialogClose="saved">` / `[mlvDialogClose]="value"` closes with
+ * that value. On a `<button>` without an explicit `type` it sets
+ * `type="button"` so it never submits a surrounding form.
+ *
+ * Put it on a `<button>` (or an `<a href>`): the directive listens to `click`
+ * only and adds no keyboard handling of its own.
+ */
+declare class MlvDialogClose<R = unknown> {
+    /** Result passed to `MlvDialogRef.close()`. A bare attribute (`''`) means `undefined`. */
+    readonly mlvDialogClose: i0.InputSignalWithTransform<R | undefined, "" | R | undefined>;
+    /** `type` attribute applied when the host is a `<button>`. Defaults to `'button'`. */
+    readonly type: i0.InputSignal<string>;
+    /** @private The dialog to close. */
+    private readonly _ref;
+    /** @private Whether the host is a native button (only then is `type` meaningful). */
+    private readonly _isButton;
+    /** @protected `type` attribute value, `null` on non-button hosts. */
+    protected readonly _type: i0.Signal<string | null>;
+    /** @protected Closes the dialog with the configured result. */
+    protected _close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDialogClose<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvDialogClose<any>, "[mlvDialogClose]", never, { "mlvDialogClose": { "alias": "mlvDialogClose"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Declarative sugar over `MlvDialogService.open(templateRef, options)`.
+ *
+ * ```html
+ * <ng-template [(mlvDialog)]="editing" [mlvDialogOptions]="{ size: 's' }" let-dialog>
+ *   <mlv-dialog>
+ *     <mlv-dialog-header title="Edit user" />
+ *     <mlv-dialog-body>…</mlv-dialog-body>
+ *     <mlv-dialog-footer><button mlvButton mlvDialogClose="saved">Save</button></mlv-dialog-footer>
+ *   </mlv-dialog>
+ * </ng-template>
+ * ```
+ *
+ * The template is instantiated only while open (lazy by default) and gets
+ * the same context as `open(templateRef)`: the ref as `let-dialog`,
+ * `let-data="data"`, `let-config="config"`. Setting the model to `true` opens,
+ * `false` closes (leave animation included), and closing from inside —
+ * `[mlvDialogClose]`, Escape, backdrop, `dialog.close()` — flips the model
+ * back to `false` and emits `mlvDialogClosed` with the result.
+ *
+ * Setting the model back to `true` while the previous instance is still
+ * leaving is honoured: the intent is remembered and a fresh dialog opens as
+ * soon as that instance is disposed, after its `mlvDialogClosed` has fired.
+ * Re-opening from **inside** an `(mlvDialogClosed)` handler is the one case
+ * that does not work: the handler runs before the model settles, so the write
+ * is overwritten. Re-open from a later tick, or while the dialog is leaving.
+ *
+ * If the host is destroyed while a dialog is open, that dialog is closed too — outputs are not emitted after the host is destroyed.
+ */
+declare class MlvDialogTemplate<R = unknown, D = unknown> {
+    /** Whether the dialog is open. Two-way bindable: `[(mlvDialog)]="open"`. */
+    readonly mlvDialog: i0.ModelSignal<boolean>;
+    /** Options passed to `MlvDialogService.open()`. Read when the dialog opens; later changes apply to the next open. */
+    readonly mlvDialogOptions: i0.InputSignal<MlvDialogConfig<D> | undefined>;
+    /** Emits after the dialog has been opened. */
+    readonly mlvDialogOpened: i0.OutputEmitterRef<void>;
+    /** Emits the close result once the dialog is disposed. */
+    readonly mlvDialogClosed: i0.OutputEmitterRef<R | undefined>;
+    /** @private The wrapped template. */
+    private readonly _template;
+    /** @private Opens the template. */
+    private readonly _dialogs;
+    /** @private Ref of the currently open (or leaving) dialog. */
+    private _ref;
+    /** @private Tears the `afterClosed()` subscription down with the host. */
+    private readonly _destroyRef;
+    /** @private Set when the model turned `true` while the previous instance was still leaving. */
+    private _reopenPending;
+    /** The ref of the open dialog (held until the leave animation completes), or `null`. */
+    get ref(): MlvDialogRef<R, D> | null;
+    constructor();
+    /** Sets the model to `true`. */
+    open(): void;
+    /** Sets the model to `false`. */
+    close(): void;
+    /** @private Opens through the service. Callers guarantee no dialog is live. */
+    private _open;
+    /** Type guard so `let-dialog` / `let-data` are typed in the template. */
+    static ngTemplateContextGuard<R, D>(_dir: MlvDialogTemplate<R, D>, _ctx: unknown): _ctx is MlvDialogTemplateContext<R, D>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDialogTemplate<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvDialogTemplate<any, any>, "ng-template[mlvDialog]", ["mlvDialog"], { "mlvDialog": { "alias": "mlvDialog"; "required": false; "isSignal": true; }; "mlvDialogOptions": { "alias": "mlvDialogOptions"; "required": false; "isSignal": true; }; }, { "mlvDialog": "mlvDialogChange"; "mlvDialogOpened": "mlvDialogOpened"; "mlvDialogClosed": "mlvDialogClosed"; }, never, never, true, never>;
+}
+
+/**
+ * Options accepted by `MlvDialogService.confirm()`.
+ *
+ * Everything but `title` and `message` is optional; labels fall back to the
+ * dialog i18n pack so a confirmation is one call with no wiring.
+ *
+ * Kept in its own file so the public barrel can re-export the shape without
+ * also exporting the internal confirmation component that consumes it.
+ */
+interface MlvConfirmDialogOptions {
+    /** Heading rendered in the dialog's header row and used as its accessible name. */
+    title: string;
+    /** Body text. Rendered as escaped text, never as HTML. */
+    message: string;
+    /** Label of the confirming action. Defaults to the localized "Confirm". */
+    confirmLabel?: string;
+    /** Label of the dismissing action. Defaults to the localized "Cancel". */
+    cancelLabel?: string;
+    /**
+     * Semantic tone of the confirmation. Drives the confirm button's variant;
+     * `'danger'` also implies {@link MlvConfirmDialogOptions.destructive}.
+     */
+    tone?: MlvTone;
+    /**
+     * Marks the action as irreversible: the confirm button turns danger-coloured
+     * and initial focus goes to **Cancel**, so a stray Enter dismisses rather
+     * than destroys.
+     */
+    destructive?: boolean;
+    /** Size preset name or explicit size config. Defaults to `'s'`. */
+    size?: MlvDialogSize;
+    /** Whether a backdrop click resolves the confirmation as `false`. Defaults to `true`. */
+    closeOnBackdrop?: boolean;
+    /** Whether Escape resolves the confirmation as `false`. Defaults to `true`. */
+    closeOnEscape?: boolean;
+    /** Parent injector for the confirmation dialog. Defaults to the root injector. */
+    injector?: Injector;
+}
+
+/**
+ * Generates a route configuration that opens a component inside a routed dialog.
+ * When the dialog closes, the router navigates back to the parent route.
+ *
+ * The component receives the shell's `Injector`, so it can inject `ActivatedRoute`
+ * to access route params, resolved data, and query params. It can also inject
+ * `MlvDialogRef` to close itself programmatically.
+ *
+ * @param component - The component to render inside the dialog. Can be an eager class reference
+ *   or a lazy import function (e.g., `() => import('./my-dialog.component')`).
+ * @param options - Route path, named outlet, and dialog configuration options.
+ * @returns A `Route` object to include in your route configuration.
+ *
+ * @example
+ * ```ts
+ * // Lazy-loaded dialog route
+ * {
+ *   path: 'users',
+ *   component: UsersListPage,
+ *   children: [
+ *     mlvGenerateRoutableDialogRoute(
+ *       () => import('./user-edit.component'),
+ *       { path: ':id/edit', size: 'l' },
+ *     ),
+ *   ],
+ * }
+ *
+ * // Eager dialog route
+ * mlvGenerateRoutableDialogRoute(UserEditComponent, {
+ *   path: ':id/edit',
+ *   size: 'l',
+ *   closeOnBackdrop: false,
+ * })
+ *
+ * // With guards and resolvers (spread the returned route)
+ * {
+ *   ...mlvGenerateRoutableDialogRoute(() => import('./confirm.component'), { path: 'confirm' }),
+ *   canActivate: [authGuard],
+ *   resolve: { item: itemResolver },
+ * }
+ * ```
+ */
+declare function mlvGenerateRoutableDialogRoute(component: Type<unknown> | (() => Promise<DefaultExport<Type<unknown>> | Type<unknown>>), { path, outlet, ...dialogOptions }?: {
+    path?: string;
+    outlet?: string;
+} & Omit<MlvDialogConfig, 'data' | 'injector'>): Route;
+
+/**
+ * Opens modal dialogs. Thin orchestration over Angular CDK `Dialog`: the CDK
+ * owns overlay, container, focus trap/restore, ARIA and history handling;
+ * this service maps `MlvDialogConfig`, constructs the `MlvDialogRef`, plays
+ * the leave animation, and applies the granular Escape/backdrop opt-outs.
+ *
+ * It never renders chrome. Template and component content must have a
+ * `<mlv-dialog>` root; string content is wrapped by an internal renderer that
+ * composes the same parts.
+ */
+declare class MlvDialogService {
+    /** @private The CDK engine. */
+    private readonly _cdk;
+    /**
+     * @private Resolves the direction for the portaled dialog pane, which never
+     * inherits a `[dir]` scope from the element that opened it.
+     */
+    private readonly _rtl;
+    /** @private Registered size presets. */
+    private readonly _presets;
+    /** @private Open Malva refs in open order, so `closeAll()` can animate each. */
+    private readonly _open;
+    /** Snapshot of the currently open dialogs, oldest first. */
+    get openDialogs(): readonly MlvDialogRef[];
+    /**
+     * Opens `content` in a modal dialog.
+     *
+     * - `TemplateRef` receives `MlvDialogTemplateContext` (`let-dialog`,
+     *   `let-data="data"`, `let-config="config"`).
+     * - A component can inject `MlvDialogRef`, `DIALOG_CONFIG`, `DIALOG_DATA`
+     *   (and the CDK `DialogRef`).
+     * - A string is rendered as escaped text under `config.title`.
+     *
+     * @param content - Template, component type, or plain text.
+     * @param config - Size, chrome defaults, closing behaviour, focus, ARIA, data, injector.
+     * @returns A typed reference that controls the dialog and emits its result.
+     */
+    open<R = unknown, D = unknown>(content: MlvDialogContent<R, D>, config?: MlvDialogConfig<D>): MlvDialogRef<R, D>;
+    /**
+     * Opens a two-action confirmation dialog and reports the user's answer.
+     *
+     * Emits exactly once and completes, so it composes with a `CanDeactivateFn`
+     * or any other guard. The answer is replayed, so late subscribers still
+     * receive it — subscribing after the dialog has already closed is fine.
+     * Every dismissal that is not the confirm button — Escape, the backdrop,
+     * `ref.close()` — resolves as `false`. When the action is `destructive` (or
+     * has the `'danger'` tone) the dialog opens as an `alertdialog`, the confirm
+     * button turns danger-coloured and initial focus goes to **Cancel**. The
+     * message paragraph always describes the dialog (`aria-describedby`).
+     *
+     * @param options - Title, message, and optional labels/tone/size.
+     * @returns `true` only if confirmed.
+     */
+    confirm(options: MlvConfirmDialogOptions): Observable<boolean>;
+    /** Closes every open dialog, newest first, playing each leave animation. */
+    closeAll(): void;
+    /** @private Registers the ref and wires the Escape/backdrop close behaviours. */
+    private _track;
+    /** @private Resolves a preset name (unknown → `'m'`) or explicit size to CDK size fields. */
+    private _resolveSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MlvDialogService>;
+}
+
+export { DIALOG_CONFIG, DIALOG_DATA, DIALOG_SIZE_PRESETS, MlvDialog, MlvDialogBody, MlvDialogClose, MlvDialogFooter, MlvDialogHeader, MlvDialogRef, MlvDialogService, MlvDialogTemplate, mlvGenerateRoutableDialogRoute };
+export type { MlvConfirmDialogOptions, MlvDialogAnimationState, MlvDialogAppearance, MlvDialogConfig, MlvDialogContent, MlvDialogFooterAlign, MlvDialogRestoreFocus, MlvDialogRestoreFocusResolver, MlvDialogRestoreFocusTarget, MlvDialogRole, MlvDialogSize, MlvDialogSizeConfig, MlvDialogSizePreset, MlvDialogSizePresets, MlvDialogTemplateContext };

package/types/malva-ui-core-divider.d.ts

@@ -0,0 +1,68 @@
+import * as _angular_core from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+
+/**
+ * Orientation of the divider line.
+ * - `'horizontal'` — a full-width horizontal rule (default)
+ * - `'vertical'` — a full-height vertical rule; requires the parent to have a defined height
+ */
+type MlvDividerOrientation = 'horizontal' | 'vertical';
+/**
+ * Divider component that renders a thin separator line between content sections.
+ *
+ * Renders an `<hr role="separator">` internally and supports an optional
+ * label projected via `<ng-content>`.  When a label is present the divider
+ * line is split into two segments flanking the label.
+ *
+ * @example Basic horizontal
+ * ```html
+ * <mlv-divider />
+ * ```
+ *
+ * @example With label
+ * ```html
+ * <mlv-divider>OR</mlv-divider>
+ * ```
+ *
+ * @example Vertical
+ * ```html
+ * <div style="display: flex; height: 2rem;">
+ *   <span>Left</span>
+ *   <mlv-divider orientation="vertical" />
+ *   <span>Right</span>
+ * </div>
+ * ```
+ *
+ * @example Dashed
+ * ```html
+ * <mlv-divider dashed />
+ * ```
+ *
+ * @example Muted
+ * ```html
+ * <mlv-divider muted />
+ * ```
+ */
+declare class MlvDivider {
+    /**
+     * The orientation of the divider line.
+     * Defaults to `'horizontal'`.
+     */
+    readonly orientation: _angular_core.InputSignal<MlvDividerOrientation>;
+    /**
+     * When `true`, renders the divider line as a dashed stroke instead of solid.
+     * Supports attribute syntax: `<mlv-divider dashed>`.
+     */
+    readonly dashed: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * When `true`, uses a more subtle border color (`--mlv-border-subtle`)
+     * instead of the default border token.
+     * Supports attribute syntax: `<mlv-divider muted>`.
+     */
+    readonly muted: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvDivider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvDivider, "mlv-divider", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "dashed": { "alias": "dashed"; "required": false; "isSignal": true; }; "muted": { "alias": "muted"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { MlvDivider };
+export type { MlvDividerOrientation };