@mk-kit/ui 0.34.0

package/types/mk-kit-ui-feedback.d.ts

@@ -0,0 +1,1270 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, Type, InjectionToken } from '@angular/core';
+import * as _mk_kit_ui_core from '@mk-kit/ui/core';
+import { MkPlacement, MkTone, MkOverlayConfig, MkOverlayRef } from '@mk-kit/ui/core';
+import * as _mk_kit_ui_feedback from '@mk-kit/ui/feedback';
+
+/** Semantic tones supported by {@link MkAlert}. */
+type MkAlertTone = 'info' | 'success' | 'warning' | 'danger' | 'neutral';
+/** Visual treatments supported by {@link MkAlert}. */
+type MkAlertVariant = 'soft' | 'solid' | 'outline';
+/**
+ * Alert — an inline banner that communicates a contextual status message.
+ * Fully themed via `--mk-*` tokens using the same tone/local-var pattern as
+ * the Button. Danger/warning alerts use `role="alert"` (assertive), all other
+ * tones use `role="status"` (polite).
+ *
+ * ```html
+ * <mk-alert tone="success" title="Saved">Your changes were saved.</mk-alert>
+ *
+ * <mk-alert tone="danger" variant="outline" dismissible (dismissed)="hide()">
+ *   <svg mkAlertIcon>…</svg>
+ *   Could not reach the server.
+ * </mk-alert>
+ * ```
+ */
+declare class MkAlert {
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** Semantic color tone. */
+    readonly tone: _angular_core.InputSignal<MkAlertTone>;
+    /** Visual treatment. */
+    readonly variant: _angular_core.InputSignal<MkAlertVariant>;
+    /** Optional bold heading rendered above the message. */
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    /** When set, renders a keyboard-accessible close button that emits `dismissed`. */
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emitted when the user activates the close button. */
+    readonly dismissed: _angular_core.OutputEmitterRef<void>;
+    /** Assertive roles for urgent tones, polite `status` otherwise. */
+    protected readonly role: _angular_core.Signal<"alert" | "status">;
+    protected onDismiss(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkAlert, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkAlert, "mk-alert", never, { "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, ["[mkAlertIcon]", "*"], true, never>;
+}
+
+/**
+ * Body-level presentation surface for {@link MkTooltip}. Rendered imperatively
+ * by the directive; not intended for direct template use.
+ */
+declare class MkTooltipPanel {
+    /** Text content shown inside the tooltip. */
+    readonly text: _angular_core.InputSignal<string>;
+    /** DOM id used to wire `aria-describedby` on the trigger. */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    /** Resolved placement relative to the trigger. */
+    readonly placement: _angular_core.InputSignal<MkPlacement>;
+    /** Drives the entrance/exit transition. */
+    readonly visible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkTooltipPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkTooltipPanel, "mk-tooltip", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Tooltip directive — shows a themed tooltip on hover AND keyboard focus, and
+ * hides on blur, mouse-leave (after a short grace period — the pointer may
+ * move onto the tooltip itself, which keeps it open, per WCAG 1.4.13), or
+ * Escape pressed anywhere while it is visible. The tooltip is appended to
+ * `document.body`, positioned relative to the host, and wired to the host via
+ * `aria-describedby` for screen-reader users. Respects `prefers-reduced-motion`.
+ *
+ * ```html
+ * <button mkButton [mkTooltip]="'Delete row'" mkTooltipPlacement="bottom">
+ *   <svg>…</svg>
+ * </button>
+ * ```
+ */
+declare class MkTooltip {
+    private readonly host;
+    private readonly appRef;
+    private readonly envInjector;
+    private readonly document;
+    private readonly isBrowser;
+    /** Set by pointerdown so the focusin it causes doesn't re-open the tip. */
+    private suppressFocusShow;
+    /** Tooltip text. When empty the tooltip is suppressed. */
+    readonly mkTooltip: _angular_core.InputSignal<string>;
+    /** Preferred placement relative to the host. */
+    readonly mkTooltipPlacement: _angular_core.InputSignal<MkPlacement>;
+    private readonly tooltipId;
+    private ref?;
+    private openTimer?;
+    private hideTimer?;
+    private previousDescribedBy;
+    /**
+     * Hovering the tooltip itself keeps it open (WCAG 1.4.13 "hoverable"): the
+     * pointer may cross the gap between trigger and panel, so leaving either one
+     * only SCHEDULES a hide, and entering either one cancels it.
+     */
+    private readonly onPanelEnter;
+    private readonly onPanelLeave;
+    /**
+     * WCAG 1.4.13 "dismissible": Escape hides a visible tooltip no matter where
+     * focus is. Attached to the document only while the tooltip is shown, and
+     * preventDefault only fires when a tooltip was actually hidden.
+     */
+    private readonly onDocumentKeydown;
+    protected onPointerEnter(): void;
+    protected onPointerLeave(): void;
+    private scheduleHide;
+    protected onFocus(): void;
+    protected onPointerDown(event: PointerEvent): void;
+    /**
+     * Outside-tap dismissal (attached to the document only while visible): a
+     * pointerdown that lands on neither the trigger nor the panel hides the
+     * tooltip. The trigger's own pointerdown handles show/hide/toggle itself,
+     * and a press on the panel keeps it up (WCAG 1.4.13 "hoverable").
+     */
+    private readonly onDocumentPointerdown;
+    private scheduleShow;
+    protected hide(): void;
+    private show;
+    private position;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MkTooltip, "[mkTooltip]", never, { "mkTooltip": { "alias": "mkTooltip"; "required": false; "isSignal": true; }; "mkTooltipPlacement": { "alias": "mkTooltipPlacement"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Popover — a non-modal floating panel for rich (non-text) content, anchored to
+ * a trigger. Unlike {@link MkTooltip} (text, hover) it holds arbitrary projected
+ * content and is opened by click via the `mkPopoverTriggerFor` directive (or the
+ * `open`/`toggle` API).
+ *
+ * The panel renders in the browser top layer through {@link MkAnchoredPanel}, so
+ * it is never clipped by an ancestor's `overflow`/`transform`. On open, focus
+ * moves into the panel; Escape closes and restores focus to the trigger, an
+ * outside click or Tabbing out closes it (non-modal — no keyboard trap).
+ *
+ * ```html
+ * <button mkButton [mkPopoverTriggerFor]="info">Details</button>
+ * <mk-popover #info ariaLabel="Details">
+ *   <h4>Shipping</h4><p>Ships in 2–3 business days.</p>
+ * </mk-popover>
+ * ```
+ */
+declare class MkPopover {
+    private readonly injector;
+    private readonly isBrowser;
+    private readonly panelRef;
+    /** Stable id for `aria-controls` on the trigger. */
+    readonly panelId: string;
+    /** Preferred placement relative to the trigger. */
+    readonly placement: _angular_core.InputSignal<MkPlacement>;
+    /** Accessible label for the dialog panel. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Move focus into the panel on open. Default `true`. */
+    readonly autoFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emitted whenever the popover closes (any reason). */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private readonly _open;
+    /** Whether the popover is open. */
+    readonly opened: _angular_core.Signal<boolean>;
+    protected readonly anchorEl: _angular_core.WritableSignal<HTMLElement | undefined>;
+    private triggerEl;
+    /** Open the popover anchored to `trigger`. */
+    open(trigger: HTMLElement): void;
+    /** Close the popover; optionally restore focus to the trigger. */
+    close(restoreFocus?: boolean): void;
+    /** Toggle open/closed from a trigger. */
+    toggle(trigger: HTMLElement): void;
+    private focusInitial;
+    protected onEscape(event: Event): void;
+    protected onPanelFocusout(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkPopover, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkPopover, "mk-popover", ["mkPopover"], { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Turns its host element into a click trigger for an `<mk-popover>`. Wires
+ * `aria-haspopup="dialog"` / `aria-expanded` / `aria-controls`, toggles on click
+ * and closes on Escape.
+ *
+ * ```html
+ * <button mkButton [mkPopoverTriggerFor]="info">Details</button>
+ * <mk-popover #info>…</mk-popover>
+ * ```
+ */
+declare class MkPopoverTrigger {
+    private readonly host;
+    /** The popover instance to control. */
+    readonly popover: _angular_core.InputSignal<MkPopover>;
+    protected onClick(event: Event): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkPopoverTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MkPopoverTrigger, "[mkPopoverTriggerFor]", ["mkPopoverTrigger"], { "popover": { "alias": "mkPopoverTriggerFor"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Popconfirm — an inline confirmation popover (e.g. a row-level "Delete?").
+ * Composes {@link MkPopover} with a message and cancel/confirm buttons, so it
+ * inherits the top-layer positioning + focus behaviour. Attach it with the
+ * `mkPopconfirmFor` directive.
+ *
+ * ```html
+ * <button mkButton tone="danger" [mkPopconfirmFor]="del">Delete</button>
+ * <mk-popconfirm #del message="Delete this item?" (confirm)="remove()" />
+ * ```
+ */
+declare class MkPopconfirm {
+    private readonly popover;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** Confirmation message. */
+    readonly message: _angular_core.InputSignal<string>;
+    /** Optional bold heading above the message. */
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    /** Confirm button label. */
+    readonly confirmText: _angular_core.InputSignal<string>;
+    /** Cancel button label. */
+    readonly cancelText: _angular_core.InputSignal<string>;
+    /** Tone of the confirm button (destructive actions use `danger`). */
+    readonly tone: _angular_core.InputSignal<MkTone>;
+    /** Preferred placement relative to the trigger. */
+    readonly placement: _angular_core.InputSignal<MkPlacement>;
+    /** Emitted when the user confirms. */
+    readonly confirm: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when the user cancels (button, Escape or outside click). */
+    readonly cancel: _angular_core.OutputEmitterRef<void>;
+    /** Id of the underlying dialog panel (for the trigger's `aria-controls`). */
+    get panelId(): string | null;
+    /** Whether the popconfirm is open. */
+    opened(): boolean;
+    /** Open anchored to `trigger`. */
+    open(trigger: HTMLElement): void;
+    /** Toggle from a trigger. */
+    toggle(trigger: HTMLElement): void;
+    /** Close the popconfirm. */
+    close(): void;
+    /** Set when the user confirms, so the close handler doesn't also cancel. */
+    private confirmed;
+    protected onConfirm(): void;
+    protected onCancel(): void;
+    /** Any close that wasn't a confirm counts as a cancel (Escape / outside). */
+    protected onPopoverClosed(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkPopconfirm, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkPopconfirm, "mk-popconfirm", ["mkPopconfirm"], { "message": { "alias": "message"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "confirmText": { "alias": "confirmText"; "required": false; "isSignal": true; }; "cancelText": { "alias": "cancelText"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, { "confirm": "confirm"; "cancel": "cancel"; }, never, never, true, never>;
+}
+
+/**
+ * Turns its host element into a click trigger for an `<mk-popconfirm>`. Wires
+ * `aria-haspopup="dialog"` / `aria-expanded` / `aria-controls`, toggles on click
+ * and closes on Escape.
+ *
+ * ```html
+ * <button mkButton tone="danger" [mkPopconfirmFor]="del">Delete</button>
+ * <mk-popconfirm #del message="Delete this item?" (confirm)="remove()" />
+ * ```
+ */
+declare class MkPopconfirmTrigger {
+    private readonly host;
+    /** The popconfirm instance to control. */
+    readonly popconfirm: _angular_core.InputSignal<MkPopconfirm>;
+    protected onClick(event: Event): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkPopconfirmTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MkPopconfirmTrigger, "[mkPopconfirmFor]", ["mkPopconfirmTrigger"], { "popconfirm": { "alias": "mkPopconfirmFor"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Status presets supported by {@link MkResult}. */
+type MkResultStatus = 'success' | 'error' | 'info' | 'warning' | '404' | '403' | '500';
+/** Built-in icon glyph chosen for a status. */
+type MkResultIconVariant = 'check' | 'x' | 'alert' | 'info' | 'search';
+/** Tone colour applied to the status icon. */
+type MkResultTone = 'success' | 'danger' | 'warning' | 'info' | 'muted';
+/**
+ * Result — a centred, full-page status state: a success confirmation, an error,
+ * an empty 404/403/500 page. Renders a large status icon (chosen from
+ * `status`), a title, a muted subtitle, projected body content, and a row of
+ * action buttons at the bottom.
+ *
+ * Slots: `[mkResultIcon]` (custom icon, overrides the built-in glyph),
+ * `[mkResultTitle]` (custom heading, used when `resultTitle` is unset), default
+ * content (extra body), `[mkResultActions]` (buttons).
+ *
+ * ```html
+ * <mk-result status="success" resultTitle="Payment complete"
+ *   subtitle="Your order is on its way.">
+ *   <button mkButton mkResultActions>Back home</button>
+ * </mk-result>
+ * ```
+ */
+declare class MkResult {
+    /** Status preset that selects the built-in icon glyph and its tone colour. */
+    readonly status: _angular_core.InputSignal<MkResultStatus>;
+    /** Main heading rendered as an `<h2>` (falls back to the `[mkResultTitle]` slot). */
+    readonly resultTitle: _angular_core.InputSignal<string>;
+    /** Supporting muted sentence under the title. */
+    readonly subtitle: _angular_core.InputSignal<string>;
+    /** Built-in glyph for the current status. */
+    protected readonly iconName: _angular_core.Signal<MkResultIconVariant>;
+    /** Tone colour applied to the status icon. */
+    protected readonly tone: _angular_core.Signal<MkResultTone>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkResult, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkResult, "mk-result", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; "resultTitle": { "alias": "resultTitle"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; }, {}, never, ["[mkResultIcon]", "[mkResultTitle]", "*", "[mkResultActions]"], true, never>;
+}
+
+/**
+ * Hovercard — a rich hover-preview panel anchored to a trigger, in the spirit of
+ * GitHub's user hovercards. Unlike {@link MkTooltip} (short text) it projects
+ * arbitrary content, and unlike {@link MkPopover} (click) it opens on hover/focus
+ * after a short delay and closes when the pointer leaves both the trigger and the
+ * card. It is driven by the `mkHovercardFor` directive (or the `open`/`close` API).
+ *
+ * The panel renders in the browser top layer through {@link MkAnchoredPanel}, so
+ * it is never clipped by an ancestor's `overflow`/`transform`. It is non-modal —
+ * no focus trap. Moving the pointer from the trigger onto the card keeps it open;
+ * Escape closes it.
+ *
+ * ```html
+ * <a href="/u/ada" [mkHovercardFor]="ada">@ada</a>
+ * <mk-hovercard #ada ariaLabel="Ada Lovelace">
+ *   <img src="/ada.png" alt="" /><strong>Ada Lovelace</strong>
+ * </mk-hovercard>
+ * ```
+ */
+declare class MkHovercard implements OnDestroy {
+    private readonly document;
+    private readonly isBrowser;
+    /** Stable id for `aria-controls` on the trigger. */
+    readonly panelId: string;
+    /** Preferred placement relative to the trigger. */
+    readonly placement: _angular_core.InputSignal<MkPlacement>;
+    /** Accessible label for the panel. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Delay in ms before the card opens on hover/focus. Default `300`. */
+    readonly openDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Delay in ms before the card closes after the pointer leaves. Default `200`. */
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Close the card when Escape is pressed while it is open. Default `true`. */
+    readonly closeOnEscape: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emitted whenever the hovercard closes (any reason). */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private readonly _open;
+    /** Whether the hovercard is open. */
+    readonly opened: _angular_core.Signal<boolean>;
+    protected readonly anchorEl: _angular_core.WritableSignal<HTMLElement | undefined>;
+    private triggerEl;
+    private openTimer;
+    private closeTimer;
+    /** Open the card anchored to `trigger` after `openDelay` (cancels a pending close). */
+    scheduleOpen(trigger: HTMLElement): void;
+    /** Close the card after `closeDelay` (cancels a pending open). */
+    scheduleClose(): void;
+    /**
+     * Keep the card open: cancel any pending open/close. Called when the pointer
+     * enters the card itself, so moving from the trigger to the card is seamless.
+     */
+    keepOpen(): void;
+    /** Open the card immediately, anchored to `trigger`. */
+    open(trigger: HTMLElement): void;
+    /** Close the card immediately. */
+    close(): void;
+    protected onCardEnter(): void;
+    protected onCardLeave(): void;
+    /**
+     * Keyboard mirror of `mouseleave`: when focus moves somewhere outside BOTH
+     * the card and its trigger, schedule a close. Focus hopping between the
+     * trigger and the card (either direction) keeps it open, so the card's
+     * content stays reachable with Tab.
+     */
+    protected onCardFocusout(event: FocusEvent): void;
+    protected onEscape(event: Event): void;
+    private setTimer;
+    private clearOpenTimer;
+    private clearCloseTimer;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkHovercard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkHovercard, "mk-hovercard", ["mkHovercard"], { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Turns its host element into a hover/focus trigger for an `<mk-hovercard>`.
+ * On `mouseenter`/`focus` it opens the card (after the card's `openDelay`),
+ * anchored to the host; on `mouseleave`/`blur` it schedules a close (after the
+ * card's `closeDelay`). Moving the pointer — or keyboard focus — from the host
+ * onto the card cancels that close, so the card stays open and its content is
+ * reachable with Tab. Escape closes it.
+ *
+ * On touch there is no hover, so a tap toggles instead: tap opens the card
+ * immediately, tapping the trigger again closes it, and a tap anywhere else
+ * closes it through the panel's outside-pointerdown dismissal.
+ *
+ * ```html
+ * <a href="/u/ada" [mkHovercardFor]="ada">@ada</a>
+ * <mk-hovercard #ada>…</mk-hovercard>
+ * ```
+ */
+declare class MkHovercardTrigger {
+    private readonly host;
+    /** Timestamp of the last touch toggle — guards `onEnter` (see above). */
+    private lastTouchToggle;
+    /** The hovercard instance to control. */
+    readonly hovercard: _angular_core.InputSignal<MkHovercard>;
+    protected onEnter(): void;
+    /**
+     * Touch tap-toggle. Mouse and pen are ignored here — they keep the pure
+     * hover/focus behaviour. A tap while the card is open closes it (a tap
+     * OUTSIDE both trigger and panel is handled by the anchored panel's own
+     * outside-pointerdown dismiss, which excludes the anchor, so the two paths
+     * never double-fire).
+     */
+    protected onPointerDown(event: PointerEvent): void;
+    protected onLeave(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkHovercardTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MkHovercardTrigger, "[mkHovercardFor]", ["mkHovercardTrigger"], { "hovercard": { "alias": "mkHovercardFor"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** A single notification shown in the {@link MkNotificationCenter} panel. */
+interface MkNotification {
+    /** Stable identity, used for `track` and immutable updates. */
+    id: unknown;
+    /** Headline line, always shown. */
+    title: string;
+    /** Optional supporting text under the title. */
+    body?: string;
+    /** Optional relative/absolute timestamp label (e.g. "2m ago"). */
+    time?: string;
+    /** Whether the user has already read this item. */
+    read?: boolean;
+}
+/**
+ * NotificationCenter — a bell trigger with an unread-count badge that opens a
+ * dropdown panel listing notifications, each markable as read.
+ *
+ * The panel renders in the browser top layer through {@link MkAnchoredPanel},
+ * so it is never clipped by an ancestor's `overflow`/`transform`. Clicking the
+ * bell toggles it; an outside click, Tabbing out or Escape closes it and
+ * restores focus to the bell. Clicking a row marks that one read (updating the
+ * two-way `notifications` immutably); "Mark all read" clears every unread item.
+ *
+ * ```html
+ * <mk-notification-center
+ *   [(notifications)]="items"
+ *   (itemClick)="open($event)"
+ *   (markedAllRead)="sync()" />
+ * ```
+ */
+declare class MkNotificationCenter {
+    private readonly injector;
+    private readonly isBrowser;
+    private readonly panelRef;
+    private readonly triggerRef;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** Stable id linking the trigger to the panel via `aria-controls`. */
+    readonly panelId: string;
+    /** Stable id for the panel's labelling heading. */
+    readonly titleId: string;
+    /** Two-way list of notifications rendered in the panel. */
+    readonly notifications: _angular_core.ModelSignal<MkNotification[]>;
+    /** Heading shown at the top of the panel. */
+    readonly panelTitle: _angular_core.InputSignal<string>;
+    /** Message shown by the empty state when there are no notifications. */
+    readonly emptyText: _angular_core.InputSignal<string>;
+    /** Max height of the scrollable list (any CSS length). */
+    readonly maxHeight: _angular_core.InputSignal<string>;
+    /** Emitted with a notification when its row is clicked. */
+    readonly itemClick: _angular_core.OutputEmitterRef<MkNotification>;
+    /** Emitted with a notification when it transitions to read. */
+    readonly read: _angular_core.OutputEmitterRef<MkNotification>;
+    /** Emitted when every notification is marked read at once. */
+    readonly markedAllRead: _angular_core.OutputEmitterRef<void>;
+    private readonly _open;
+    /** Whether the panel is open. */
+    readonly open: _angular_core.Signal<boolean>;
+    /** Count of notifications that are not yet read. */
+    readonly unreadCount: _angular_core.Signal<number>;
+    /** Accessible label for the bell trigger. */
+    protected readonly triggerLabel: _angular_core.Signal<string>;
+    /** Badge text, capped at "99+". */
+    protected readonly badgeText: _angular_core.Signal<string>;
+    /** Toggle the panel open/closed. */
+    toggle(): void;
+    /** Open the panel, moving focus into it on the next render. */
+    openPanel(): void;
+    /** Close the panel; optionally restore focus to the bell trigger. */
+    close(restoreFocus?: boolean): void;
+    /** Mark every notification read and emit {@link markedAllRead}. */
+    markAllRead(): void;
+    /** Handle a row click: mark it read (if needed) and emit {@link itemClick}. */
+    protected onRowClick(item: MkNotification): void;
+    private markRead;
+    protected onEscape(event: Event): void;
+    protected onPanelFocusout(event: FocusEvent): void;
+    private focusInitial;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkNotificationCenter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkNotificationCenter, "mk-notification-center", never, { "notifications": { "alias": "notifications"; "required": false; "isSignal": true; }; "panelTitle": { "alias": "panelTitle"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; }, { "notifications": "notificationsChange"; "itemClick": "itemClick"; "read": "read"; "markedAllRead": "markedAllRead"; }, never, never, true, never>;
+}
+
+/**
+ * Accessible heading for a dialog. Renders as a level-2 heading and exposes a
+ * stable id that {@link MkDialog} wires to the panel's `aria-labelledby`.
+ *
+ * ```html
+ * <mk-dialog>
+ *   <mk-dialog-title>Delete workspace</mk-dialog-title>
+ *   …
+ * </mk-dialog>
+ * ```
+ */
+declare class MkDialogTitle {
+    /** Stable id used for `aria-labelledby` wiring. */
+    readonly id: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDialogTitle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkDialogTitle, "mk-dialog-title", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * Dialog layout — a surface with a sticky header, scrollable body, and sticky
+ * footer, designed to be rendered inside an {@link MkOverlayService} panel. The
+ * header exposes a close button wired to the injected {@link MkOverlayRef} and
+ * the dialog's title is linked to the panel via `aria-labelledby`.
+ *
+ * Slots: `[mkDialogHeader]` / `<mk-dialog-title>` (header), default content
+ * (body), `[mkDialogFooter]` (footer).
+ *
+ * ```html
+ * <mk-dialog>
+ *   <mk-dialog-title>Rename</mk-dialog-title>
+ *   <p>Choose a new name.</p>
+ *   <div mkDialogFooter>
+ *     <button mkButton variant="ghost">Cancel</button>
+ *     <button mkButton>Save</button>
+ *   </div>
+ * </mk-dialog>
+ * ```
+ */
+declare class MkDialog {
+    private readonly host;
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly overlayRef;
+    /** Optional plain-text title. Ignored when a `<mk-dialog-title>` is projected. */
+    readonly dialogTitle: _angular_core.InputSignal<string | undefined>;
+    /** Stable id for the built-in title element. */
+    readonly titleId: _angular_core.InputSignal<string>;
+    /** Hide the header close button. */
+    readonly hideClose: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    /** Close the surrounding overlay, if any. */
+    protected close(): void;
+    /** Point the owning dialog panel's `aria-labelledby` at the title element. */
+    private wireLabelledBy;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkDialog, "mk-dialog", never, { "dialogTitle": { "alias": "dialogTitle"; "required": false; "isSignal": true; }; "titleId": { "alias": "titleId"; "required": false; "isSignal": true; }; "hideClose": { "alias": "hideClose"; "required": false; "isSignal": true; }; }, {}, never, ["[mkDialogHeader], mk-dialog-title", "*", "[mkDialogFooter]"], true, never>;
+}
+
+/** Data contract for {@link MkConfirmDialog} / `MkDialogService.confirm`. */
+interface MkConfirmDialogData {
+    /** Heading text. */
+    title: string;
+    /** Body message. */
+    message: string;
+    /** Confirm button label. Default `Confirm`. */
+    confirmText?: string;
+    /** Cancel button label. Default `Cancel`. */
+    cancelText?: string;
+    /** Tone of the confirm button (and `alertdialog` semantics when `danger`). */
+    tone?: 'primary' | 'danger' | 'warning' | 'success';
+    /**
+     * Optional registered icon name shown beside the message. Useful when the
+     * action is destructive and the wording alone carries no visual weight
+     * (`trash`, `alert-triangle`, `user-x`).
+     */
+    icon?: string;
+    /** Hide the cancel button — a single-button acknowledgement (`alert`). */
+    hideCancel?: boolean;
+}
+/**
+ * Internal component backing `MkDialogService.confirm`. Renders a title,
+ * message, and cancel/confirm buttons. Resolves the overlay ref with `true`
+ * on confirm and `false` on cancel. Uses `alertdialog` semantics for the
+ * `danger` tone (set on the panel by the service).
+ */
+declare class MkConfirmDialog {
+    private readonly ref;
+    protected readonly data: MkConfirmDialogData;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    protected readonly confirmTone: _angular_core.Signal<"success" | "warning" | "danger" | "primary">;
+    protected readonly confirmText: _angular_core.Signal<string>;
+    protected readonly cancelText: _angular_core.Signal<string>;
+    protected confirm(): void;
+    protected cancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkConfirmDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkConfirmDialog, "mk-confirm-dialog", never, {}, {}, never, never, true, never>;
+}
+
+/** Data contract for {@link MkPromptDialog} / `MkDialogService.prompt`. */
+interface MkPromptDialogData {
+    /** Heading text. */
+    title: string;
+    /** Optional body message shown above the input. */
+    message?: string;
+    /** Field label. */
+    label?: string;
+    /** Pre-filled value. */
+    value?: string;
+    /** Input placeholder. */
+    placeholder?: string;
+    /** Confirm button label. Default `OK`. */
+    confirmText?: string;
+    /** Cancel button label. Default `Cancel`. */
+    cancelText?: string;
+    /** Require a non-empty value before the confirm button enables. */
+    required?: boolean;
+    /** Native input type (e.g. `text`, `email`, `number`, `password`). */
+    inputType?: string;
+}
+/**
+ * Internal component backing `MkDialogService.prompt`. Renders a single text
+ * field and resolves the overlay ref with the entered string on confirm, or
+ * `null` on cancel / Escape / backdrop. Submitting the form (Enter) confirms.
+ */
+declare class MkPromptDialog {
+    private readonly ref;
+    protected readonly data: MkPromptDialogData;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly inputRef;
+    protected readonly value: _angular_core.WritableSignal<string>;
+    protected readonly confirmText: _angular_core.Signal<string>;
+    protected readonly cancelText: _angular_core.Signal<string>;
+    protected readonly canConfirm: _angular_core.Signal<boolean>;
+    constructor();
+    protected onInput(event: Event): void;
+    protected submit(): void;
+    protected cancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkPromptDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkPromptDialog, "mk-prompt-dialog", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Panel width preset. The panel is always `min(target, 92vw)`, so it shrinks to
+ * fit a phone and grows to its target on a desktop.
+ *
+ * - `sm` (32rem) — the default; confirmations, single-field prompts
+ * - `md` (45rem) — two-column forms
+ * - `lg` (56rem) — forms with nested sections
+ * - `xl` (75rem) — tables or side-by-side content inside a modal
+ */
+type MkDialogSize = 'sm' | 'md' | 'lg' | 'xl';
+/** Configuration for `MkDialogService.open`. Extends the raw overlay config. */
+interface MkDialogConfig<TData = unknown> extends MkOverlayConfig<TData> {
+    /** Panel width preset. Defaults to `sm`, matching pre-0.9 behaviour. */
+    size?: MkDialogSize;
+}
+/**
+ * Dialog service — a thin, opinionated layer over {@link MkOverlayService} that
+ * renders content on a themed `--mk-surface` panel (shadow, radius, entrance
+ * animation) and adds a `confirm()` convenience.
+ *
+ * ```ts
+ * const ref = dialog.open(EditUserDialog, { data: user });
+ * const saved = await ref.afterClosed;
+ *
+ * if (await dialog.confirm({ title: 'Delete?', message: 'This cannot be undone.', tone: 'danger' })) {
+ *   remove();
+ * }
+ * ```
+ */
+declare class MkDialogService {
+    private readonly overlay;
+    private readonly i18n;
+    /** Open `component` inside a themed dialog panel. */
+    open<TComponent, TResult = unknown, TData = unknown>(component: Type<TComponent>, config?: MkDialogConfig<TData>): MkOverlayRef<TResult, TComponent>;
+    /**
+     * Open a confirmation dialog. Resolves `true` if confirmed, `false` if the
+     * user cancels, presses Escape, or clicks the backdrop.
+     */
+    confirm(data: MkConfirmDialogData): Promise<boolean>;
+    /**
+     * Open a single-button acknowledgement dialog. Resolves when the user
+     * dismisses it (button, Escape, or backdrop).
+     */
+    alert(data: Omit<MkConfirmDialogData, 'hideCancel' | 'cancelText'>): Promise<void>;
+    /**
+     * Open a single-field prompt dialog. Resolves with the entered string, or
+     * `null` if the user cancels, presses Escape, or clicks the backdrop.
+     */
+    prompt(data: MkPromptDialogData): Promise<string | null>;
+    private mergePanelClass;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDialogService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MkDialogService>;
+}
+
+/** Semantic tones supported by toasts. */
+type MkToastTone = 'info' | 'success' | 'warning' | 'danger' | 'neutral';
+/** An optional action button rendered inside a toast. */
+interface MkToastAction {
+    /** Button label. */
+    label: string;
+    /** Invoked when the action is activated. The toast is dismissed afterwards. */
+    handler?: () => void;
+}
+/** Options accepted by {@link MkToastService.show}. */
+interface MkToastConfig {
+    /** Optional bold heading. */
+    title?: string;
+    /** Body message (required). */
+    message: string;
+    /** Semantic tone. Default `info`. */
+    tone?: MkToastTone;
+    /** Auto-dismiss delay in ms. `0` keeps the toast until dismissed. Default `5000`. */
+    duration?: number;
+    /** Show a close button. Default `true`. */
+    dismissible?: boolean;
+    /** Optional action button. */
+    action?: MkToastAction;
+}
+/** A live toast rendered by the container. */
+interface MkToastItem {
+    readonly id: number;
+    readonly title?: string;
+    readonly message: string;
+    readonly tone: MkToastTone;
+    readonly duration: number;
+    readonly dismissible: boolean;
+    readonly action?: MkToastAction;
+}
+/**
+ * Toast service — enqueues transient notifications rendered by a single,
+ * lazily-mounted {@link MkToastContainer} at the bottom-right of the viewport.
+ * Each rendered toast is itself a live region (`role="alert"` for `danger`,
+ * else `role="status"`), so assistive tech announces it exactly once. Toasts
+ * auto-dismiss after `duration` ms unless it is `0`.
+ *
+ * ```ts
+ * toasts.success('Saved');
+ * toasts.show({ title: 'Upload failed', message: 'Retry?', tone: 'danger',
+ *   duration: 0, action: { label: 'Retry', handler: () => retry() } });
+ * ```
+ */
+declare class MkToastService {
+    private readonly appRef;
+    private readonly envInjector;
+    private readonly document;
+    private readonly isBrowser;
+    private readonly _toasts;
+    /** Reactive list of currently visible toasts. */
+    readonly toasts: _angular_core.Signal<readonly MkToastItem[]>;
+    private readonly timers;
+    private containerRef?;
+    /** Show a toast, returning its id (usable with {@link dismiss}). */
+    show(config: MkToastConfig): number;
+    /** Show an `info` toast. */
+    info(message: string, config?: Partial<MkToastConfig>): number;
+    /** Show a `success` toast. */
+    success(message: string, config?: Partial<MkToastConfig>): number;
+    /** Show a `warning` toast. */
+    warning(message: string, config?: Partial<MkToastConfig>): number;
+    /** Show a `danger` toast. */
+    danger(message: string, config?: Partial<MkToastConfig>): number;
+    /** Show a `neutral` toast. */
+    neutral(message: string, config?: Partial<MkToastConfig>): number;
+    /** Dismiss a toast by id. */
+    dismiss(id: number): void;
+    /** Dismiss every visible toast. */
+    clear(): void;
+    /** Run a toast action, then dismiss it. */
+    runAction(item: MkToastItem): void;
+    /** Pause a toast's auto-dismiss countdown (e.g. on hover/focus). */
+    pause(id: number): void;
+    /** Resume a paused countdown. */
+    resume(id: number): void;
+    private startTimer;
+    private clearTimer;
+    private ensureContainer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MkToastService>;
+}
+
+/**
+ * A single toast card. Internal to the toast system — rendered by
+ * {@link MkToastContainer}. Displays a tone accent, optional title, message,
+ * optional action button, and (when dismissible) a close button. Auto-dismiss
+ * pauses while the toast is hovered or focused.
+ */
+declare class MkToast {
+    private readonly service;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** The toast model to render. */
+    readonly item: _angular_core.InputSignal<MkToastItem>;
+    /** Assertive alert for danger, polite status otherwise. */
+    protected readonly role: _angular_core.Signal<"alert" | "status">;
+    protected dismiss(): void;
+    protected runAction(): void;
+    protected pause(): void;
+    protected resume(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkToast, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkToast, "mk-toast", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Fixed, bottom-right stack that renders the active toasts from
+ * {@link MkToastService}. Mounted once, lazily, into `document.body` by the
+ * service — not intended for direct template use.
+ */
+declare class MkToastContainer {
+    private readonly service;
+    /** Live list of toasts to render. */
+    protected readonly toasts: _angular_core.Signal<readonly _mk_kit_ui_feedback.MkToastItem[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkToastContainer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkToastContainer, "mk-toast-container", never, {}, {}, never, never, true, never>;
+}
+
+/** Semantic tone of a snackbar. `neutral` is the default dark bar. */
+type MkSnackbarTone = 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+/** Why a snackbar closed. */
+type MkSnackbarDismissReason = 'action' | 'timeout' | 'dismiss';
+/** Options for {@link MkSnackbarService.open}. */
+interface MkSnackbarConfig {
+    /** Semantic tone. Default `neutral`. */
+    tone?: MkSnackbarTone;
+    /** Auto-dismiss delay in ms. `0` keeps it open until dismissed. Default `5000`. */
+    duration?: number;
+    /** Show a close (×) button. Default `false` (dismiss via action/timeout). */
+    dismissible?: boolean;
+    /**
+     * @deprecated The snackbar element is itself the live region — its
+     * politeness is derived from `tone` (`alert` for danger/warning, else
+     * `status`). This option is ignored.
+     */
+    politeness?: 'polite' | 'assertive';
+}
+/** The live snackbar model rendered by the container. */
+interface MkSnackbarItem {
+    readonly id: number;
+    readonly message: string;
+    readonly actionLabel?: string;
+    readonly tone: MkSnackbarTone;
+    readonly dismissible: boolean;
+}
+/**
+ * Handle to an opened snackbar. Await {@link onAction} to react to the action
+ * button, or {@link afterDismissed} to run code once it closes.
+ */
+declare class MkSnackbarRef {
+    /** Unique id of the snackbar this ref controls. */
+    readonly id: number;
+    private readonly service;
+    private actionResolve;
+    private dismissResolve;
+    private readonly actionPromise;
+    private readonly dismissPromise;
+    constructor(
+    /** Unique id of the snackbar this ref controls. */
+    id: number, service: MkSnackbarService);
+    /** Dismiss the snackbar programmatically. */
+    dismiss(): void;
+    /** Resolves when the action button is activated. */
+    onAction(): Promise<void>;
+    /** Resolves when the snackbar has closed, with the reason it closed. */
+    afterDismissed(): Promise<MkSnackbarDismissReason>;
+    /** @internal */
+    _notifyAction(): void;
+    /** @internal */
+    _notifyDismissed(reason: MkSnackbarDismissReason): void;
+}
+/**
+ * Snackbar service — shows a single, brief message at the bottom-centre of the
+ * viewport with an optional action button, following the Material snackbar
+ * model: only one is visible at a time, and opening a new one replaces the
+ * current. For stacked, persistent notifications use `MkToastService` instead.
+ *
+ * ```ts
+ * const ref = snackbar.open('Message archived', 'Undo');
+ * ref.onAction().then(() => restore());
+ *
+ * snackbar.open('Changes saved', undefined, { tone: 'success' });
+ * ```
+ */
+declare class MkSnackbarService {
+    private readonly appRef;
+    private readonly envInjector;
+    private readonly document;
+    private readonly isBrowser;
+    private readonly _active;
+    /** The currently visible snackbar, or `null`. */
+    readonly active: _angular_core.Signal<MkSnackbarItem | null>;
+    private readonly refs;
+    private timer?;
+    private remaining;
+    private startedAt;
+    private containerRef?;
+    /**
+     * Open a snackbar. `action` is the (optional) button label — react to it via
+     * the returned ref's {@link MkSnackbarRef.onAction}.
+     */
+    open(message: string, action?: string, config?: MkSnackbarConfig): MkSnackbarRef;
+    /** Dismiss the snackbar with the given id (if it is the active one). */
+    dismiss(id: number): void;
+    /** Run the action for the active snackbar, then close it. */
+    runAction(id: number): void;
+    /** Pause the auto-dismiss countdown (e.g. on hover/focus). */
+    pause(): void;
+    /** Resume a paused countdown. */
+    resume(): void;
+    private close;
+    private startTimer;
+    private clearTimer;
+    private ensureContainer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkSnackbarService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MkSnackbarService>;
+}
+
+/**
+ * The visual snackbar bar. Internal to the snackbar system — rendered by
+ * {@link MkSnackbarContainer}. Shows a message, an optional action button and
+ * (when `dismissible`) a close button. Auto-dismiss pauses on hover/focus.
+ */
+declare class MkSnackbar {
+    private readonly service;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** The snackbar model to render. */
+    readonly item: _angular_core.InputSignal<MkSnackbarItem>;
+    /** Assertive alert for danger/warning, polite status otherwise. */
+    protected readonly role: _angular_core.Signal<"alert" | "status">;
+    protected runAction(): void;
+    protected dismiss(): void;
+    protected pause(): void;
+    protected resume(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkSnackbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkSnackbar, "mk-snackbar", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Fixed, bottom-centre host that renders the single active snackbar from
+ * {@link MkSnackbarService}. Mounted once, lazily, into `document.body` by the
+ * service — not intended for direct template use.
+ */
+declare class MkSnackbarContainer {
+    private readonly service;
+    /** The active snackbar to render, or `null`. */
+    protected readonly active: _angular_core.Signal<_mk_kit_ui_feedback.MkSnackbarItem | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkSnackbarContainer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkSnackbarContainer, "mk-snackbar-container", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * BottomSheet layout — the surface rendered inside an {@link MkOverlayService}
+ * panel by {@link MkBottomSheetService}. Provides a drag handle (swipe down to
+ * dismiss), an optional titled header with a close button, and a scrollable
+ * body for projected content.
+ *
+ * Slots: `[mkBottomSheetHeader]` (extra header content), default content
+ * (body), `[mkBottomSheetFooter]` (sticky footer).
+ *
+ * ```html
+ * <mk-bottom-sheet sheetTitle="Share">
+ *   <button mkButton fullWidth variant="ghost">Copy link</button>
+ *   <button mkButton fullWidth variant="ghost">Email</button>
+ * </mk-bottom-sheet>
+ * ```
+ */
+declare class MkBottomSheet {
+    private readonly host;
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly overlayRef;
+    /** Optional plain-text title rendered in the header. */
+    readonly sheetTitle: _angular_core.InputSignal<string | undefined>;
+    /** Stable id for the built-in title element. */
+    readonly titleId: _angular_core.InputSignal<string>;
+    /** Hide the drag handle (also disables swipe-to-dismiss). */
+    readonly hideHandle: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Hide the header close button. */
+    readonly hideClose: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private panel;
+    private dragging;
+    private startY;
+    constructor();
+    /** Close the surrounding overlay, if any. */
+    protected close(): void;
+    protected onHandlePointerDown(event: PointerEvent): void;
+    protected onHandlePointerMove(event: PointerEvent): void;
+    protected onHandlePointerUp(event: PointerEvent): void;
+    /** Point the owning panel's `aria-labelledby` at the title element. */
+    private wireLabelledBy;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkBottomSheet, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkBottomSheet, "mk-bottom-sheet", never, { "sheetTitle": { "alias": "sheetTitle"; "required": false; "isSignal": true; }; "titleId": { "alias": "titleId"; "required": false; "isSignal": true; }; "hideHandle": { "alias": "hideHandle"; "required": false; "isSignal": true; }; "hideClose": { "alias": "hideClose"; "required": false; "isSignal": true; }; }, {}, never, ["[mkBottomSheetHeader]", "*", "[mkBottomSheetFooter]"], true, never>;
+}
+
+/** Configuration for `MkBottomSheetService.open`. Extends the overlay config. */
+interface MkBottomSheetConfig<TData = unknown> extends MkOverlayConfig<TData> {
+}
+/**
+ * BottomSheet service — a thin layer over {@link MkOverlayService} that renders
+ * a component in a panel anchored to the bottom edge of the viewport: full
+ * width on small screens, a centred card capped at ~42rem on large ones. It
+ * slides up on open and can be swiped down to dismiss (via {@link MkBottomSheet}).
+ *
+ * Use it for contextual actions, pickers and mobile-style menus. For a centred
+ * modal use `MkDialogService` instead.
+ *
+ * ```ts
+ * const ref = bottomSheet.open(ShareSheet, { data: { url } });
+ * const choice = await ref.afterClosed;
+ * ```
+ */
+declare class MkBottomSheetService {
+    private readonly overlay;
+    /** Open `component` inside a bottom-anchored sheet panel. */
+    open<TComponent, TResult = unknown, TData = unknown>(component: Type<TComponent>, config?: MkBottomSheetConfig<TData>): MkOverlayRef<TResult, TComponent>;
+    private mergePanelClass;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkBottomSheetService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MkBottomSheetService>;
+}
+
+/**
+ * Banner — a persistent, full-width page/section message with a tone, optional
+ * title, an actions slot and optional dismiss. Heavier than an inline
+ * {@link MkAlert} toast; use it for standing notices ("Trial ends in 3 days").
+ *
+ * Project an icon with `[mkBannerIcon]` and buttons with `[mkBannerActions]`.
+ * Danger/warning banners announce assertively (`role="alert"`).
+ *
+ * ```html
+ * <mk-banner tone="warning" title="Storage almost full" dismissible>
+ *   You've used 90% of your quota.
+ *   <button mkButton size="sm" mkBannerActions>Upgrade</button>
+ * </mk-banner>
+ * ```
+ */
+declare class MkBanner {
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** Semantic color tone. */
+    readonly tone: _angular_core.InputSignal<MkTone>;
+    /** Optional bold title above the message. */
+    readonly title: _angular_core.InputSignal<string>;
+    /** Show a dismiss (×) button. */
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Two-way open state; set false to hide. */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** Emitted when the banner is dismissed. */
+    readonly dismissed: _angular_core.OutputEmitterRef<void>;
+    protected readonly role: _angular_core.Signal<"alert" | "status">;
+    protected dismiss(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkBanner, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkBanner, "mk-banner", never, { "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "dismissed": "dismissed"; }, never, ["[mkBannerIcon]", "*", "[mkBannerActions]"], true, never>;
+}
+
+/**
+ * LoadingBar — a thin progress bar fixed to the top of the viewport, driven by
+ * {@link MkLoadingBarService}. Place it once (e.g. in the app shell) and call
+ * `start()` / `complete()` on navigation or async work.
+ *
+ * ```html
+ * <mk-loading-bar />
+ * ```
+ */
+declare class MkLoadingBar {
+    private readonly service;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** Bar colour. */
+    readonly color: _angular_core.InputSignal<string>;
+    /** Bar thickness in px. */
+    readonly height: _angular_core.InputSignalWithTransform<number, unknown>;
+    protected readonly progress: _angular_core.Signal<number>;
+    protected readonly active: _angular_core.Signal<boolean>;
+    /**
+     * The fill is a full-width bar scaled from the inline start — `transform`
+     * animates on the compositor, so each trickle tick avoids the layout+paint
+     * cost that animating `width` incurred. Origin flips for RTL in the styles.
+     */
+    protected readonly fillTransform: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkLoadingBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkLoadingBar, "mk-loading-bar", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Drives a global {@link MkLoadingBar} — the thin top-of-page progress bar for
+ * route changes and background work. `start()` shows it and trickles toward 90%;
+ * `complete()` finishes and hides it. Also supports a determinate `set(value)`.
+ *
+ * ```ts
+ * const bar = inject(MkLoadingBarService);
+ * router.events.subscribe(e => {
+ *   if (e instanceof NavigationStart) bar.start();
+ *   if (e instanceof NavigationEnd) bar.complete();
+ * });
+ * ```
+ */
+declare class MkLoadingBarService {
+    private readonly isBrowser;
+    private readonly _progress;
+    private readonly _active;
+    /** Current progress, 0–100. */
+    readonly progress: _angular_core.Signal<number>;
+    /** Whether the bar is visible. */
+    readonly active: _angular_core.Signal<boolean>;
+    private timer?;
+    private doneTimer?;
+    /** Show the bar and start trickling toward 90%. */
+    start(): void;
+    /** Set an explicit determinate value (0–100). */
+    set(value: number): void;
+    /** Nudge progress up by `amount` (default 5), capped at 90%. */
+    inc(amount?: number): void;
+    /** Finish (jump to 100%) then fade out. */
+    complete(): void;
+    /** Hide immediately without finishing. */
+    stop(): void;
+    /**
+     * Auto-slowing trickle so the bar keeps moving without ever completing.
+     * Stops its own interval at the 90% ceiling — otherwise a navigation that
+     * never `complete()`s would leave a timer firing (and, in a zoneless app,
+     * scheduling change detection) forever. `start()`/`inc()` re-arm it.
+     */
+    private trickle;
+    /** Start the 350ms trickle interval unless it is already running. */
+    private armTrickle;
+    private stopTrickle;
+    private clearTimers;
+    /** True while finishing (progress full but not yet hidden). */
+    readonly finishing: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkLoadingBarService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MkLoadingBarService>;
+}
+
+/**
+ * A single coach-mark step in a product tour. The `target` is the element the
+ * step points at — either a live `HTMLElement` or a CSS selector resolved
+ * against the document when the step is shown.
+ */
+interface MkTourStep {
+    /** Element (or selector) the popover anchors to and highlights. */
+    target: string | HTMLElement;
+    /** Optional heading shown above the body. */
+    title?: string;
+    /** The explanatory copy for this step. */
+    body: string;
+    /** Preferred placement of the popover relative to the target. */
+    placement?: MkPlacement;
+}
+/** Navigation callbacks the popup invokes on the owning {@link MkTourService}. */
+interface MkTourController {
+    next(): void;
+    prev(): void;
+    end(): void;
+}
+/** Per-step data injected into {@link MkTourPopup} via {@link MK_TOUR_DATA}. */
+interface MkTourData {
+    /** The step being shown. */
+    step: MkTourStep;
+    /** Zero-based index of this step. */
+    index: number;
+    /** Total number of steps in the tour. */
+    total: number;
+    /** The resolved target element to anchor against. */
+    anchor: HTMLElement;
+    /** Navigation handle back to the service. */
+    controller: MkTourController;
+}
+/** DI token carrying the current {@link MkTourData} to the popup. */
+declare const MK_TOUR_DATA: InjectionToken<MkTourData>;
+/**
+ * The floating coach-mark popover for one tour step. Rendered dynamically by
+ * {@link MkTourService} (one instance per step) and anchored to the step's
+ * target through {@link MkAnchoredPanel}, so it lives in the browser top layer
+ * and is never clipped by an ancestor's `overflow`/`transform`.
+ */
+declare class MkTourPopup {
+    private readonly injector;
+    private readonly panelRef;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** The step + navigation data for this popup. */
+    protected readonly data: MkTourData;
+    /** Whether this is the final step (Next becomes "Done"). */
+    protected readonly isLast: _angular_core.Signal<boolean>;
+    constructor();
+    protected next(): void;
+    protected prev(): void;
+    protected skip(): void;
+    protected onEscape(event: Event): void;
+    /**
+     * Ignore anchored-panel dismisses (outside pointerdown / window blur): a tour
+     * should stay put while the user reads it — it ends only via the buttons or
+     * Escape.
+     */
+    protected onDismiss(): void;
+    /**
+     * Trap Tab inside the popup (the dialog is `aria-modal` over a scrim): wrap
+     * from the last tabbable back to the first and vice versa, and pull focus in
+     * if it somehow ended up outside.
+     */
+    protected onTab(event: Event): void;
+    private focusInitial;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkTourPopup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkTourPopup, "mk-tour-popup", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Product-onboarding tour service — walks the user through a sequence of
+ * {@link MkTourStep}s. For each step it scrolls the target into view, dims the
+ * page behind a scrim, highlights the target with a bright ring, and anchors a
+ * coach-mark popover ({@link MkTourPopup}) to it in the browser top layer via
+ * `MkAnchoredPanel`.
+ *
+ * ```ts
+ * const tour = inject(MkTourService);
+ * await tour.start([
+ *   { target: '#new-btn', title: 'Create', body: 'Start a project here.' },
+ *   { target: '#inbox', body: 'Your notifications land here.', placement: 'left' },
+ * ]);
+ * ```
+ */
+declare class MkTourService {
+    private readonly appRef;
+    private readonly envInjector;
+    private readonly document;
+    private readonly isBrowser;
+    private readonly _steps;
+    private readonly _index;
+    private readonly _running;
+    /** Zero-based index of the current step, or `-1` when no tour is running. */
+    readonly index: _angular_core.Signal<number>;
+    /** Whether a tour is currently active. */
+    readonly running: _angular_core.Signal<boolean>;
+    /** Total number of steps in the active tour. */
+    readonly total: _angular_core.Signal<number>;
+    /** The current step, or `null`. */
+    readonly currentStep: _angular_core.Signal<MkTourStep | null>;
+    private popupRef?;
+    private scrim?;
+    private snapshot?;
+    private endResolve?;
+    private endPromise;
+    /** Element focused before start(); focus is restored to it on end(). */
+    private previouslyFocused;
+    constructor();
+    /**
+     * Begin a tour at step 0. Returns a promise that resolves when the tour ends
+     * (finished, skipped, or Escaped).
+     */
+    start(steps: MkTourStep[]): Promise<void>;
+    /** Resolves when the active (or next) tour ends. */
+    afterEnd(): Promise<void>;
+    /** Advance to the next step, or finish on the last step. */
+    next(): void;
+    /** Return to the previous step (no-op at the first step). */
+    prev(): void;
+    /** End the tour and clean up all DOM, highlight, and listeners. */
+    end(): void;
+    private readonly onKeydown;
+    /**
+     * Render the step at `index`. Missing targets are skipped by continuing in
+     * `dir` (+1 forward, -1 back); if none remain the tour ends.
+     */
+    private showStep;
+    /** Destroy the current popup and restore the current target's styles. */
+    private teardownStep;
+    private resolveTarget;
+    /** Raise the target above the scrim and draw a bright ring around it. */
+    private highlight;
+    private unhighlight;
+    private ensureScrim;
+    private removeScrim;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkTourService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MkTourService>;
+}
+
+export { MK_TOUR_DATA, MkAlert, MkBanner, MkBottomSheet, MkBottomSheetService, MkConfirmDialog, MkDialog, MkDialogService, MkDialogTitle, MkHovercard, MkHovercardTrigger, MkLoadingBar, MkLoadingBarService, MkNotificationCenter, MkPopconfirm, MkPopconfirmTrigger, MkPopover, MkPopoverTrigger, MkPromptDialog, MkResult, MkSnackbar, MkSnackbarContainer, MkSnackbarRef, MkSnackbarService, MkToast, MkToastContainer, MkToastService, MkTooltip, MkTooltipPanel, MkTourPopup, MkTourService };
+export type { MkAlertTone, MkAlertVariant, MkBottomSheetConfig, MkConfirmDialogData, MkDialogConfig, MkDialogSize, MkNotification, MkPromptDialogData, MkResultIconVariant, MkResultStatus, MkResultTone, MkSnackbarConfig, MkSnackbarDismissReason, MkSnackbarItem, MkSnackbarTone, MkToastAction, MkToastConfig, MkToastItem, MkToastTone, MkTourController, MkTourData, MkTourStep };