@wildmason/aegis 1.5.4

package/dist/types/wildmason-aegis.d.ts

@@ -0,0 +1,545 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef, AfterViewInit, TemplateRef, OnDestroy } from '@angular/core';
+import { ConnectedPosition } from '@angular/cdk/overlay';
+import { ControlValueAccessor } from '@angular/forms';
+
+/**
+ * WmModal — Lightweight modal backdrop with Escape key and click-outside dismissal.
+ *
+ * Owns the fixed backdrop, centering, and keyboard/pointer dismissal so individual
+ * modal components don't need to repeat this logic or add their own HostListeners.
+ *
+ * Usage:
+ *   <wm-modal [visible]="visible()" (dismiss)="close()">
+ *     <div class="p-6 wm-r-md w-80" style="background: var(--wm-bg-raised)">
+ *       <!-- modal panel content -->
+ *     </div>
+ *   </wm-modal>
+ *
+ * For top-aligned panels (e.g. search/command palettes), use align="top":
+ *   <wm-modal [visible]="visible()" (dismiss)="close()" align="top">
+ *
+ * The projected content is wrapped in a stop-propagation container so clicks inside
+ * the panel do not bubble up to the backdrop and trigger a dismiss.
+ */
+declare class WmModal {
+    /** Whether the modal is currently open. */
+    visible: _angular_core.InputSignal<boolean>;
+    /** Emitted when the user requests the modal to close (Escape or backdrop click). */
+    dismiss: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Vertical alignment of the panel within the backdrop.
+     * - 'center' (default): panel is vertically centered (items-center)
+     * - 'top': panel appears near the top (items-start pt-20), for search/command overlays
+     */
+    align: _angular_core.InputSignal<"center" | "top">;
+    onEscape(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WmModal, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WmModal, "wm-modal", never, { "visible": { "alias": "visible"; "required": true; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; }, { "dismiss": "dismiss"; }, never, ["*"], true, never>;
+}
+
+type DialogSize = 'sm' | 'md' | 'lg';
+/**
+ * WmDialog — Modal dialog with backdrop, focus trap, and Escape key handling.
+ *
+ * Renders a fixed-position overlay that is always viewport-relative (not clipped
+ * by ancestor overflow:hidden). Do NOT place inside a container that uses
+ * CSS transform, perspective, or filter — fixed positioning breaks in that context.
+ *
+ * Usage:
+ *   <wm-dialog [(isOpen)]="open" title="Confirm action">
+ *     <div body>
+ *       <p>Are you sure?</p>
+ *       <div class="wm-dialog-footer">
+ *         <wm-button variant="secondary" (click)="open.set(false)">Cancel</wm-button>
+ *         <wm-button variant="primary" (click)="onConfirm()">Confirm</wm-button>
+ *       </div>
+ *     </div>
+ *   </wm-dialog>
+ *
+ * Accessibility:
+ *  - role="dialog" + aria-modal="true" on the panel
+ *  - aria-labelledby wired to the title element (when title is set)
+ *  - Focus is trapped inside the panel when open (cdkTrapFocus)
+ *  - Escape key closes the dialog
+ *  - Clicking the backdrop closes the dialog
+ *  - On close, focus returns to the element that opened the dialog
+ *    (browser default when focus trap is released)
+ */
+declare class WmDialog {
+    /** Two-way binding for open/closed state. */
+    isOpen: _angular_core.ModelSignal<boolean>;
+    /** Dialog heading text. When set, aria-labelledby is applied automatically. */
+    title: _angular_core.InputSignal<string>;
+    /** Panel width preset. sm = 360px, md = 480px (default), lg = 640px. */
+    size: _angular_core.InputSignal<DialogSize>;
+    close(): void;
+    onEscape(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WmDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WmDialog, "wm-dialog", never, { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; }, never, ["[body]"], true, never>;
+}
+
+/**
+ * SelectOption — data model for WmSelect options.
+ *
+ * Used as items in the [options] input on <wm-select>.
+ */
+interface SelectOption {
+    /** The value that will be emitted when this option is selected. */
+    value: unknown;
+    /** The text label displayed in the trigger and in the dropdown list. */
+    label: string;
+    /** When true, the option is visible but cannot be selected. */
+    disabled?: boolean;
+}
+
+/**
+ * WmSelect — Accessible dropdown select built on Angular CDK Overlay.
+ *
+ * Provides a styled, keyboard-accessible alternative to the native <select> element
+ * when you need custom option rendering or consistent cross-platform appearance.
+ *
+ * When to use:
+ *  - Single selection from a list of 4+ options
+ *  - When option labels are complex (icons, descriptions, status badges)
+ *  - When native <select> appearance is insufficient
+ *
+ * When NOT to use:
+ *  - 3 or fewer options → use a radio group (more scannable, no extra click)
+ *  - Multi-select → use a checkbox group or a combobox with chips
+ *  - Yes/No choices → use a Toggle or two radio buttons
+ *
+ * Options API:
+ *   options: SelectOption[]  — Array of { value, label, disabled? } objects.
+ *
+ * Two-way binding:
+ *   <wm-select [(value)]="selectedValue" [options]="myOptions" />
+ *
+ * Accessibility:
+ *  - Trigger has role="combobox", aria-expanded, aria-haspopup="listbox"
+ *  - Panel has role="listbox"; each option has role="option" + aria-selected
+ *  - Disabled options have aria-disabled="true"
+ *  - Focus is trapped inside the open panel (cdkTrapFocus)
+ *  - Clicking the backdrop closes the panel and returns focus to the trigger
+ *  - Keyboard: Enter/Space on trigger opens; Escape closes; arrow keys
+ *    navigate options (relies on natural tab order within the panel)
+ *  - Always pair with a visible label via <wm-label> or aria-label on the host
+ */
+declare class WmSelect {
+    /** Array of options to display. */
+    options: _angular_core.InputSignal<SelectOption[]>;
+    /** The currently selected value. Two-way bindable. */
+    value: _angular_core.ModelSignal<unknown>;
+    /** Placeholder text shown when no option is selected. */
+    placeholder: _angular_core.InputSignal<string>;
+    /** Disables the trigger and prevents the panel from opening. */
+    disabled: _angular_core.InputSignal<boolean>;
+    protected isOpen: _angular_core.WritableSignal<boolean>;
+    protected selectedOption: _angular_core.Signal<SelectOption>;
+    private hostEl;
+    protected get overlayWidth(): number;
+    protected positions: ConnectedPosition[];
+    protected toggleOpen(): void;
+    protected selectOption(opt: SelectOption): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WmSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WmSelect, "wm-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * WmPopover — general-purpose CDK-overlay floating panel.
+ *
+ * A low-level primitive for dropdowns, menus, pickers, and any floating UI.
+ * The parent controls open/close state; this component handles positioning,
+ * backdrop, focus-trapping, and ARIA attribute management.
+ *
+ * Slots:
+ *  - [trigger]  — the anchor element (button, icon, etc.)
+ *  - [content]  — the panel body (menu items, form, etc.)
+ *
+ * Usage:
+ * ```html
+ * <wm-popover [isOpen]="open()" (closed)="open.set(false)" role="menu" hasPopup="menu" align="end">
+ *   <button trigger (click)="open.set(!open())">Options</button>
+ *   <div content role="menu">
+ *     <button role="menuitem" (click)="doThing()">Do thing</button>
+ *   </div>
+ * </wm-popover>
+ * ```
+ *
+ * Accessibility:
+ *  - Trigger element automatically receives aria-haspopup, aria-expanded, aria-controls
+ *  - Panel receives the configured role
+ *  - Focus is trapped inside the open panel (cdkTrapFocus)
+ *  - Escape key closes the panel
+ *  - Backdrop click closes the panel
+ *
+ * Auto-focus:
+ *  - Add [wmAutoFocus] to any element inside [content] to focus it on open.
+ *    Import WmAutoFocus from @wildmason/aegis/components and add it to your component's imports.
+ */
+declare class WmPopover {
+    /** Whether the panel is currently open. */
+    readonly isOpen: _angular_core.InputSignal<boolean>;
+    /** Panel width in pixels, or 'auto' to match content. */
+    readonly width: _angular_core.InputSignal<string | number>;
+    /** ARIA role for the floating panel element. Use 'menu', 'listbox', 'dialog', etc. */
+    readonly role: _angular_core.InputSignal<string>;
+    /** Value for aria-haspopup on the trigger element. */
+    readonly hasPopup: _angular_core.InputSignal<string | boolean>;
+    /** Horizontal alignment: 'start' aligns left edges, 'end' aligns right edges. */
+    readonly align: _angular_core.InputSignal<"start" | "end">;
+    /** Emitted when the panel should close (backdrop click, Escape key, CDK detach). */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private readonly renderer;
+    private readonly hostEl;
+    private readonly cdr;
+    protected readonly panelId: string;
+    protected readonly panel: _angular_core.Signal<ElementRef<HTMLElement>>;
+    constructor();
+    protected get positions(): ConnectedPosition[];
+    protected onAttach(): void;
+    protected onClose(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WmPopover, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WmPopover, "wm-popover", never, { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "hasPopup": { "alias": "hasPopup"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["[trigger]", "[content]"], true, never>;
+}
+
+/**
+ * WmAutoFocus — focuses an element when it enters the DOM.
+ *
+ * Usage: add [wmAutoFocus] to any focusable element inside a <wm-popover> panel.
+ * For date/time/color/select inputs, also attempts to open the native picker UI.
+ *
+ * @example
+ * <input wmAutoFocus type="text" />
+ * <input [wmAutoFocus]="shouldFocus" type="date" />
+ */
+declare class WmAutoFocus implements AfterViewInit {
+    #private;
+    enabled: boolean | '';
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WmAutoFocus, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WmAutoFocus, "[wmAutoFocus]", never, { "enabled": { "alias": "wmAutoFocus"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class WmTab {
+    readonly value: _angular_core.InputSignal<string>;
+    readonly tmpl: _angular_core.Signal<TemplateRef<void>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WmTab, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WmTab, "wm-tab", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class WmTabs {
+    activeValue: _angular_core.InputSignal<string>;
+    variant: _angular_core.InputSignal<"line" | "pill">;
+    readonly select: _angular_core.OutputEmitterRef<string>;
+    protected readonly tabs: _angular_core.Signal<readonly WmTab[]>;
+    protected focusedIndex: _angular_core.WritableSignal<number>;
+    protected selectTab(value: string, index: number): void;
+    protected onBlur(): void;
+    protected onKeyDown(event: KeyboardEvent, container: HTMLElement): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WmTabs, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WmTabs, "wm-tabs", never, { "activeValue": { "alias": "activeValue"; "required": true; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "select": "select"; }, ["tabs"], never, true, never>;
+}
+
+type ButtonVariant = 'primary' | 'secondary' | 'ghost' | 'destructive' | 'flat';
+type ButtonSize = 'xs' | 'sm' | 'md' | 'lg';
+declare class WmButton {
+    readonly variant: _angular_core.InputSignal<ButtonVariant>;
+    readonly size: _angular_core.InputSignal<ButtonSize>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly type: _angular_core.InputSignal<"button" | "submit" | "reset">;
+    /** Makes the button square (equal width/height). Use for icon-only buttons. */
+    readonly iconOnly: _angular_core.InputSignal<boolean>;
+    /** Accessible label forwarded to the inner <button>. Required for icon-only buttons. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Tooltip text forwarded to the inner <button>. Named btnTitle to avoid native attribute conflict. */
+    readonly btnTitle: _angular_core.InputSignal<string>;
+    protected readonly btnClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WmButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WmButton, "wm-button", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "btnTitle": { "alias": "btnTitle"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * WmCheckbox — Boolean selection control with optional indeterminate state.
+ *
+ * When to use:
+ *  - Multi-select lists (each item is independent)
+ *  - Form options that require explicit confirmation before taking effect
+ *  - Parent/child hierarchical selection (use indeterminate for "some selected")
+ *
+ * When NOT to use:
+ *  - Mutually exclusive choices → use radio buttons instead
+ *  - Immediate-effect toggles (e.g. dark mode) → use Toggle instead
+ *
+ * Accessibility:
+ *  - role="checkbox" with aria-checked="true|false|mixed"
+ *  - "mixed" maps to the indeterminate state for screen readers
+ *  - Space activates the checkbox (native button behaviour)
+ *  - Focus ring uses a double-ring (canvas gap + accent) pattern for maximum visibility
+ *    across all themes, meeting WCAG 2.1 SC 1.4.11 Non-text Contrast
+ *  - When wrapping in a group, add role="group" + aria-labelledby to the container
+ */
+declare class Checkbox {
+    /** Two-way bindable checked state. */
+    checked: _angular_core.ModelSignal<boolean>;
+    /**
+     * Shows a dash icon instead of a checkmark. Typically used for a "select all"
+     * checkbox when only some child items are selected.
+     * Note: indeterminate is display-only — clicking always toggles to true/false.
+     */
+    indeterminate: _angular_core.InputSignal<boolean>;
+    /** Visible text label rendered next to the checkbox box. */
+    label: _angular_core.InputSignal<string>;
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Maps to aria-checked: true, false, or "mixed" (for indeterminate). */
+    protected ariaChecked: _angular_core.Signal<boolean | "mixed">;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Checkbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Checkbox, "wm-checkbox", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, never, true, never>;
+}
+
+/**
+ * WmNumberInput — Numeric input with stepper buttons.
+ *
+ * Implements ControlValueAccessor so it works with both template-driven forms
+ * (ngModel) and reactive forms (formControl / formControlName).
+ *
+ * When to use:
+ *  - Quantity fields (items in cart, repetitions, page count)
+ *  - Bounded numeric settings with a known min/max (timeout seconds, font size)
+ *
+ * When NOT to use:
+ *  - Free-form numeric entry without bounds → plain <input type="number">
+ *  - Currency or phone numbers → use a text input with masking
+ *
+ * Accessibility:
+ *  - The underlying <input type="number"> is the focusable control.
+ *  - Stepper buttons have tabindex="-1" — they are mouse/touch targets only.
+ *    Keyboard users use the arrow keys on the input itself (native browser behaviour).
+ *  - Always provide an aria-label or visible label via <wm-field> + <wm-label>.
+ *  - The buttons use mousedown + preventDefault to avoid stealing focus from the input.
+ *
+ * Form integration:
+ *   <!-- Template-driven -->
+ *   <wm-number-input [(ngModel)]="count" [min]="0" [max]="100" />
+ *
+ *   <!-- Reactive -->
+ *   <wm-number-input formControlName="quantity" [step]="5" />
+ */
+declare class NumberInput implements ControlValueAccessor {
+    /** Minimum allowed value. */
+    min: _angular_core.InputSignal<number>;
+    /** Maximum allowed value. */
+    max: _angular_core.InputSignal<number>;
+    /** Amount to increment/decrement per step. Defaults to 1. */
+    step: _angular_core.InputSignal<number>;
+    /** Placeholder text shown when the field is empty. */
+    placeholder: _angular_core.InputSignal<string>;
+    /** Disables the control from the template. Also set automatically by reactive forms. */
+    disabled: _angular_core.InputSignal<boolean>;
+    protected inputRef: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    protected internalValue: _angular_core.WritableSignal<number>;
+    private onChangeFn;
+    protected onTouchedFn: () => void;
+    /** CVA interface — called when the form model changes programmatically. */
+    writeValue(value: number | null): void;
+    registerOnChange(fn: (v: number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    protected onInputChange(event: Event): void;
+    protected increment(): void;
+    protected decrement(): void;
+    /**
+     * Prevents the stepper buttons from stealing focus away from the input element.
+     * Without this, clicking a button would blur the input, hiding any validation state.
+     */
+    protected preventFocusSteal(event: MouseEvent): void;
+    private setValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberInput, "wm-number-input", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * WmToggle — Binary on/off control.
+ *
+ * Use for settings that take effect immediately without a form submit.
+ * For settings that need an explicit "Save" action, prefer a checkbox.
+ *
+ * Accessibility:
+ *  - role="switch" communicates binary state to screen readers
+ *  - aria-checked reflects true/false
+ *  - aria-label required when no visible text label surrounds the toggle
+ *  - Space and Enter activate the toggle (native button behaviour)
+ *  - When disabled, aria state is preserved so SR users understand why it can't be changed
+ */
+declare class Toggle {
+    /** Two-way bindable state. Use [(checked)]="mySignal" or [checked]="val" (changeChecked)="val=$event". */
+    checked: _angular_core.ModelSignal<boolean>;
+    /** Visually and functionally disables the toggle. State is still readable by assistive tech. */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Accessible label. Required if no visible label text surrounds the toggle in the DOM. */
+    ariaLabel: _angular_core.InputSignal<string>;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Toggle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Toggle, "wm-toggle", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, never, true, never>;
+}
+
+/**
+ * GhostField — transparent-until-hover wrapper for inline-editable fields.
+ *
+ * Applies .wm-ghost-field to its content; all visual behaviour is CSS-driven
+ * (inputs.css). No inputs or outputs — interactivity belongs to the inner
+ * element projected via ng-content.
+ *
+ * Usage:
+ *   <wm-ghost-field>
+ *     <input class="wm-input-bare" [(ngModel)]="title" aria-label="Task title" />
+ *   </wm-ghost-field>
+ */
+declare class GhostField {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GhostField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GhostField, "wm-ghost-field", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * PageHeader — standardised page-level heading with eyebrow label, title,
+ * optional subtitle, optional status badge, and projected action/back slots.
+ *
+ * Slots:
+ *   [icon]   — 12×12 icon projected into the eyebrow row (optional)
+ *   [back]   — back-navigation element (link or button) placed in the status row (optional)
+ *   default  — action buttons / controls placed below the status row
+ *
+ * Usage:
+ *   <wm-page-header flavourText="Sprints" title="Active Sprint" [badgeLabel]="daysLeft">
+ *     <svg icon .../>
+ *     <a back href="...">← Board</a>
+ *     <wm-button>New Sprint</wm-button>
+ *   </wm-page-header>
+ */
+declare class PageHeader {
+    readonly flavourText: _angular_core.InputSignal<string>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly subtitle: _angular_core.InputSignal<string>;
+    readonly badgeLabel: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PageHeader, "wm-page-header", never, { "flavourText": { "alias": "flavourText"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": true; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "badgeLabel": { "alias": "badgeLabel"; "required": false; "isSignal": true; }; }, {}, never, ["[icon]", "[back]", "*"], true, never>;
+}
+
+type ToastType = 'success' | 'error' | 'info' | 'progress';
+interface Toast {
+    id: number;
+    message: string;
+    type: ToastType;
+    /** If true, toast does not auto-dismiss. Caller must dismiss it manually. */
+    persistent?: boolean;
+    /** Epoch ms when this toast was created (used for elapsed time display). */
+    createdAt?: number;
+    /** Callback invoked when the user clicks the Cancel button (progress toasts only). */
+    onCancel?: () => void;
+}
+/**
+ * WmToastService — Application-wide toast notification manager.
+ *
+ * Provided in root; inject anywhere and call success(), error(), info(), or progress().
+ * Render `<wm-toast-container>` once at the app root to display toasts.
+ *
+ * Auto-dismiss: success/info after 4 s, error after 6 s.
+ * Progress toasts persist until explicitly dismissed.
+ * Custom duration via show(message, type, durationMs).
+ */
+declare class WmToastService {
+    readonly toasts: _angular_core.WritableSignal<Toast[]>;
+    show(message: string, type?: ToastType, duration?: number): number;
+    success(message: string): number;
+    error(message: string): number;
+    info(message: string): number;
+    /**
+     * Show a persistent progress toast with spinner and elapsed timer.
+     * Returns the toast ID — caller must call dismiss(id) when done.
+     *
+     * @param message - Display message (e.g. "Generating docs…")
+     * @param onCancel - Optional callback invoked when the user clicks Cancel.
+     *                   The caller should abort the operation and then dismiss the toast.
+     */
+    progress(message: string, onCancel?: () => void): number;
+    dismiss(id: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WmToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WmToastService>;
+}
+
+/**
+ * WmToastContainer — Renders the current stack of toasts.
+ *
+ * Place once at the application root (e.g. inside the shell or app component).
+ * Uses inline SVG icons — no external icon library dependency.
+ *
+ * Accessibility:
+ *  - Container has role="log" + aria-live="polite" so new toasts are announced
+ *  - Each toast has role="status"
+ *  - Dismiss button has an accessible label
+ */
+declare class WmToastContainer implements OnDestroy {
+    protected readonly toastService: WmToastService;
+    /** Tick signal that updates every second — drives the elapsed time display. */
+    protected readonly tick: _angular_core.WritableSignal<number>;
+    private tickInterval;
+    ngOnDestroy(): void;
+    protected dismiss(id: number): void;
+    protected cancel(toast: Toast): void;
+    protected typeClass(toast: Toast): string;
+    protected elapsed(createdAt: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WmToastContainer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WmToastContainer, "wm-toast-container", never, {}, {}, never, never, true, never>;
+}
+
+interface LicenseStatus {
+    valid: boolean;
+    org: string | null;
+    product: string;
+    seats: number | null;
+    tier: string | null;
+    expires: string | null;
+    key_id: string | null;
+    error: string | null;
+}
+
+declare class WmLicenseService {
+    private toast;
+    readonly license: _angular_core.WritableSignal<LicenseStatus>;
+    readonly isLicensed: _angular_core.Signal<boolean>;
+    readonly orgName: _angular_core.Signal<string>;
+    checkLicense(): Promise<void>;
+    installKey(jwt: string): Promise<LicenseStatus>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WmLicenseService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WmLicenseService>;
+}
+
+declare class WmLicenseNudge {
+    private licenseService;
+    dismissed: _angular_core.WritableSignal<boolean>;
+    enterLicense: _angular_core.OutputEmitterRef<void>;
+    protected readonly shouldShow: () => boolean;
+    dismiss(): void;
+    onEnterLicense(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WmLicenseNudge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WmLicenseNudge, "wm-license-nudge", never, {}, { "enterLicense": "enterLicense"; }, never, never, true, never>;
+}
+
+declare class WmLicenseDialog {
+    private licenseService;
+    visible: _angular_core.InputSignal<boolean>;
+    dismiss: _angular_core.OutputEmitterRef<void>;
+    keyInput: _angular_core.WritableSignal<string>;
+    validationResult: _angular_core.WritableSignal<LicenseStatus>;
+    validating: _angular_core.WritableSignal<boolean>;
+    installed: _angular_core.WritableSignal<boolean>;
+    onDismiss(): void;
+    onKeyInput(event: Event): void;
+    validate(): Promise<void>;
+    private reset;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WmLicenseDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WmLicenseDialog, "wm-license-dialog", never, { "visible": { "alias": "visible"; "required": true; "isSignal": true; }; }, { "dismiss": "dismiss"; }, never, never, true, never>;
+}
+
+export { Checkbox, GhostField, NumberInput, PageHeader, Toggle, WmAutoFocus, WmButton, WmDialog, WmLicenseDialog, WmLicenseNudge, WmLicenseService, WmModal, WmPopover, WmSelect, WmTab, WmTabs, WmToastContainer, WmToastService };
+export type { ButtonSize, ButtonVariant, DialogSize, LicenseStatus, SelectOption, Toast, ToastType };