@malva-ui/core 0.1.12

package/day-picker/lib/day-picker/day-picker.d.ts

@@ -0,0 +1,51 @@
+import type { MlvFormState, MlvFormControl } from '@malva-ui/core/form-utils';
+import { MlvSignalFormControlBase } from '@malva-ui/core/form-utils';
+import * as i0 from "@angular/core";
+/**
+ * Visual/validation state of the day picker. Mirrors {@link MlvFormState}.
+ */
+export type MlvDayPickerState = MlvFormState;
+export declare class MlvDayPicker<D = Date> extends MlvSignalFormControlBase<D | null> implements MlvFormControl {
+    /** @private Active date adapter — injected token, falling back to the native adapter. */
+    private readonly _dateAdapter;
+    readonly value: import("@angular/core").ModelSignal<D | null>;
+    /** Custom placeholder override. Falls back to the i18n-provided placeholder. */
+    readonly placeholder: import("@angular/core").InputSignal<string | undefined>;
+    readonly min: import("@angular/core").InputSignalWithTransform<D | null, D | null | undefined>;
+    readonly max: import("@angular/core").InputSignalWithTransform<D | null, D | null | undefined>;
+    readonly dateFormat: import("@angular/core").InputSignal<string>;
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvDayPickerI18n>;
+    /** @protected Resolved placeholder: explicit input takes precedence over i18n default. */
+    protected readonly _resolvedPlaceholder: import("@angular/core").Signal<string>;
+    readonly focused: import("@angular/core").Signal<boolean>;
+    readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * The HTML `id` assigned to the visible `<mlv-label>` element. The trigger
+     * references it via `aria-labelledby` (a `<label for>` cannot name a `<div>`).
+     */
+    readonly labelId: import("@angular/core").Signal<string>;
+    /** The HTML `id` of the calendar dialog region, for `aria-controls` linking. */
+    readonly popupId: import("@angular/core").Signal<string>;
+    /** @private Reference to the trigger element for focus restoration on close. */
+    private readonly _triggerRef;
+    get displayValue(): string;
+    toggleDropdown(): void;
+    onDateSelected(date: D | null): void;
+    /** @protected Marks the control touched when the trigger loses focus. */
+    protected _onTriggerBlur(): void;
+    /**
+     * @protected Called after the calendar popup opens. Moves focus into the
+     * calendar dialog so keyboard users land inside the modal surface.
+     */
+    protected _onPopupOpened(): void;
+    /**
+     * @protected Called after the calendar popup closes. Restores focus to the
+     * trigger element and clears the focused flag.
+     */
+    protected _onPopupClosed(): void;
+    /** Whether the control holds a clearable value — A date is set. */
+    readonly hasValue: import("@angular/core").Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDayPicker<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvDayPicker<any>, "mlv-day-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "dateFormat": { "alias": "dateFormat"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}

package/day-picker/malva-ui-core-day-picker.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@malva-ui/core/day-picker" />
+export * from './index';

package/dialog/index.d.ts

@@ -0,0 +1,11 @@
+export * from './lib/dialog-config';
+export * from './lib/dialog-ref';
+export * from './lib/dialog/dialog';
+export * from './lib/dialog-header';
+export * from './lib/dialog-body';
+export * from './lib/dialog-footer';
+export * from './lib/dialog-close';
+export * from './lib/dialog-template';
+export * from './lib/confirm-dialog-options';
+export * from './lib/generate-routable-dialog-route';
+export * from './lib/dialog.service';

package/dialog/lib/confirm-dialog-options.d.ts

@@ -0,0 +1,41 @@
+import type { Injector } from '@angular/core';
+import type { MlvTone } from '@malva-ui/cdk/utils';
+import type { MlvDialogSize } from './dialog-config';
+/**
+ * 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.
+ */
+export 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;
+}

package/dialog/lib/confirm-dialog.d.ts

@@ -0,0 +1,52 @@
+import type { MlvButtonVariant } from '@malva-ui/core/button';
+import type { MlvConfirmDialogOptions } from './confirm-dialog-options';
+import * as i0 from "@angular/core";
+/** @internal Class on the confirm button — also the `initialFocus` selector. */
+export declare const MLV_CONFIRM_DIALOG_CONFIRM_CLASS = "mlv-confirm-dialog__confirm";
+/** @internal Class on the cancel button — also the `initialFocus` selector. */
+export declare const MLV_CONFIRM_DIALOG_CANCEL_CLASS = "mlv-confirm-dialog__cancel";
+/**
+ * @internal Content of a `MlvDialogService.confirm()` dialog: the standard
+ * surface with a titled header (no close button — the service opens it with
+ * `appearance: 'confirm'`), the message, and the two actions. Options arrive
+ * through `MlvDialogRef.data`, so this file never imports the service.
+ */
+export declare class MlvConfirmDialog {
+    /** @private Handle used to resolve the confirmation. */
+    private readonly _ref;
+    /** @private i18n strings for the default labels. */
+    private readonly _i18n;
+    /** @protected The options this confirmation was opened with. */
+    protected readonly _options: MlvConfirmDialogOptions;
+    /**
+     * @protected Id of the message paragraph. `confirm()` generates it and puts
+     * it on `MlvDialogConfig.ariaDescribedBy`, so the container already points at
+     * this element; reading it back here keeps `MlvConfirmDialogOptions` free of
+     * an id the caller never supplies. The fallback only matters if the component
+     * is ever opened without that config — the paragraph still gets a unique id.
+     */
+    protected readonly _messageId: string;
+    /** @protected Resolved label of the confirming action; follows the active language. */
+    protected readonly _confirmLabel: import("@angular/core").Signal<string>;
+    /** @protected Resolved label of the dismissing action; follows the active language. */
+    protected readonly _cancelLabel: import("@angular/core").Signal<string>;
+    /**
+     * @protected Button variant of the confirming action. `destructive` and the
+     * `'danger'` tone both mean "cannot be undone", so either makes it dangerous;
+     * every other tone maps through {@link CONFIRM_VARIANT_BY_TONE}, and no tone
+     * at all stays `'primary'`.
+     */
+    protected readonly _confirmVariant: MlvButtonVariant;
+    /** @protected Resolves the confirmation as accepted. */
+    protected _confirm(): void;
+    /** @protected Resolves the confirmation as declined. */
+    protected _cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvConfirmDialog, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvConfirmDialog, "mlv-confirm-dialog", never, {}, {}, never, never, true, never>;
+}
+/**
+ * @internal Whether a confirmation describes an irreversible action. Shared by
+ * the component (button variant) and the service (initial focus) so the two
+ * cannot disagree about which action is the safe one.
+ */
+export declare function mlvIsDestructiveConfirm(options: MlvConfirmDialogOptions): boolean;

package/dialog/lib/dialog/dialog.d.ts

@@ -0,0 +1,22 @@
+import * as i0 from "@angular/core";
+/**
+ * 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.
+ */
+export declare class MlvDialog {
+    /** @protected The dialog this surface belongs to. */
+    protected readonly _ref: import("@malva-ui/core/dialog").MlvDialogRef<unknown, unknown>;
+    /** @protected Per-open configuration; `appearance` drives the confirm modifier. */
+    protected readonly _config: Readonly<import("@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>;
+}

package/dialog/lib/dialog-body.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+/**
+ * Scrollable body of a dialog. Wraps its content in `mlv-scrollbar` (padding
+ * sits inside the scroll viewport so focus rings are never clipped).
+ */
+export declare class MlvDialogBody {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDialogBody, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvDialogBody, "mlv-dialog-body, [mlvDialogBody]", never, {}, {}, never, ["*"], true, never>;
+}

package/dialog/lib/dialog-close.d.ts

@@ -0,0 +1,27 @@
+import * as i0 from "@angular/core";
+/**
+ * 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.
+ */
+export declare class MlvDialogClose<R = unknown> {
+    /** Result passed to `MlvDialogRef.close()`. A bare attribute (`''`) means `undefined`. */
+    readonly mlvDialogClose: import("@angular/core").InputSignalWithTransform<R | undefined, "" | R | undefined>;
+    /** `type` attribute applied when the host is a `<button>`. Defaults to `'button'`. */
+    readonly type: import("@angular/core").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: import("@angular/core").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>;
+}

package/dialog/lib/dialog-config.d.ts

@@ -0,0 +1,112 @@
+import type { Injector, TemplateRef, Type } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import type { MlvOverlayInitialFocus } from '@malva-ui/cdk/overlay';
+import type { MlvDialogRef } from './dialog-ref';
+/** Built-in size preset names. Any other string resolves through `DIALOG_SIZE_PRESETS`. */
+export type MlvDialogSizePreset = 's' | 'm' | 'l' | 'fullscreen';
+/** Explicit dialog dimensions. Numbers are pixels; strings are any CSS length. */
+export 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`. */
+export 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`.
+ */
+export type MlvDialogSize = MlvDialogSizePreset | (string & {}) | MlvDialogSizeConfig;
+/** `'confirm'` drops the header/footer borders and hides the close button. */
+export type MlvDialogAppearance = 'default' | 'confirm';
+/** ARIA role of the dialog container. */
+export type MlvDialogRole = 'dialog' | 'alertdialog';
+/** Registered dialog size presets. Override to add or change presets app-wide. */
+export 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`.
+ */
+export interface MlvDialogConfig<D = unknown> {
+    /** Preset name or explicit dimensions. Defaults to `'m'`. */
+    size?: MlvDialogSize;
+    /** 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;
+    /** Whether focus returns to the previously focused element on close. Defaults to `true`. */
+    restoreFocus?: boolean;
+    /** 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.
+ */
+export declare const DIALOG_DATA: InjectionToken<unknown>;
+/** The consumer's `MlvDialogConfig` for the current dialog, injectable by content and parts. */
+export 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`.
+ */
+export 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. */
+export type MlvDialogContent<R = unknown, D = unknown> = string | TemplateRef<MlvDialogTemplateContext<R, D>> | Type<unknown>;

package/dialog/lib/dialog-container.d.ts

@@ -0,0 +1,40 @@
+import { CdkDialogContainer } from '@angular/cdk/dialog';
+import * as i0 from "@angular/core";
+/**
+ * @internal Malva's CDK dialog container: focus trap, ARIA attributes and
+ * focus restore come from `CdkDialogContainer`; this subclass adds Malva's
+ * `initialFocus` strategy on top of the CDK's container focus and restates the
+ * host bindings. Ivy does inherit host bindings and attributes from a
+ * superclass, so that restatement is belt-and-braces — it mirrors what Angular
+ * Material's `MatDialogContainer` does, and keeps the contract visible next to
+ * the styles that depend on it.
+ *
+ * **Deliberate exception to the repo's "OnPush on every library component"
+ * rule:** `changeDetection` is `Eager`, matching `CdkDialogContainer` and
+ * `MatDialogContainer`. This container's view is the change-detection parent of
+ * arbitrary consumer content (the portal outlet's `ViewContainerRef` lives in
+ * it), so an OnPush, non-dirty container would skip refreshing embedded or
+ * component content whose bindings are driven by non-signal, zone-based state.
+ *
+ * Not exported — `MlvDialogService` passes it as `DialogConfig.container`.
+ */
+export declare class MlvDialogContainer extends CdkDialogContainer {
+    /** @private The consumer's Malva config — `initialFocus` is the only field read here. */
+    private readonly _mlvConfig;
+    /** @private Shared overlay initial-focus strategy (`'auto'` skips the close button and scroll viewport). */
+    private readonly _initialFocus;
+    /** @private Injector for `afterNextRender` (the CDK's own is private). */
+    private readonly _hostInjector;
+    /** @private Set on destroy so a pending focus callback becomes a no-op. */
+    private _destroyed;
+    constructor();
+    /**
+     * @protected The CDK first focuses the container (`autoFocus: 'dialog'`,
+     * emitting `_focusTrapped` so the CDK hides the rest of the page from AT),
+     * then — after the same render, before paint — Malva moves focus to the
+     * resolved `initialFocus` target.
+     */
+    protected _captureInitialFocus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDialogContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvDialogContainer, "mlv-dialog-container", never, {}, {}, never, never, true, never>;
+}

package/dialog/lib/dialog-footer.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+/** Horizontal alignment of a dialog footer's actions. */
+export 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.
+ */
+export declare class MlvDialogFooter {
+    /** Where the actions sit: `'start'`, `'end'` (default), `'center'`, or `'between'`. */
+    readonly align: import("@angular/core").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>;
+}

package/dialog/lib/dialog-header.d.ts

@@ -0,0 +1,74 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * 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.
+ */
+export declare class MlvDialogHeader {
+    /** Plain-text title rendered as `<h2>`. Wins over projected content and the config title. */
+    readonly title: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * Whether the close button is rendered. Unset → `MlvDialogConfig.closable`
+     * → `true`. Ignored (always hidden) when the dialog `appearance` is `'confirm'`.
+     */
+    readonly closable: import("@angular/core").InputSignalWithTransform<boolean | undefined, BooleanInput>;
+    /** @protected The dialog this header labels and closes. */
+    protected readonly _ref: import("@malva-ui/core/dialog").MlvDialogRef<unknown, unknown>;
+    /** @protected Per-open configuration (title / closable / appearance fallbacks). */
+    protected readonly _config: Readonly<import("@malva-ui/core/dialog").MlvDialogConfig<unknown>>;
+    /** @protected i18n strings — `closeDialog` labels the X. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@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: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected The rendered title element, in either branch. Its text decides
+     * whether the dialog is labelled by this header.
+     */
+    protected readonly _titleEl: import("@angular/core").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>;
+}

package/dialog/lib/dialog-ref.d.ts

@@ -0,0 +1,95 @@
+import type { DialogRef } from '@angular/cdk/dialog';
+import type { Signal } from '@angular/core';
+import type { Observable } from 'rxjs';
+import type { MlvDialogConfig } from './dialog-config';
+/** Lifecycle of the surface animation driven by `MlvDialogRef.animationState`. */
+export 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`.
+ */
+export 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;
+}

package/dialog/lib/dialog-template.d.ts

@@ -0,0 +1,65 @@
+import type { MlvDialogConfig, MlvDialogTemplateContext } from './dialog-config';
+import type { MlvDialogRef } from './dialog-ref';
+import * as i0 from "@angular/core";
+/**
+ * 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.
+ */
+export declare class MlvDialogTemplate<R = unknown, D = unknown> {
+    /** Whether the dialog is open. Two-way bindable: `[(mlvDialog)]="open"`. */
+    readonly mlvDialog: import("@angular/core").ModelSignal<boolean>;
+    /** Options passed to `MlvDialogService.open()`. Read when the dialog opens; later changes apply to the next open. */
+    readonly mlvDialogOptions: import("@angular/core").InputSignal<MlvDialogConfig<D> | undefined>;
+    /** Emits after the dialog has been opened. */
+    readonly mlvDialogOpened: import("@angular/core").OutputEmitterRef<void>;
+    /** Emits the close result once the dialog is disposed. */
+    readonly mlvDialogClosed: import("@angular/core").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>;
+}