@atelier-ui/angular 0.0.1

package/types/atelier-ui-angular.d.ts

@@ -0,0 +1,1278 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, WritableSignal, Signal, OnInit, OnDestroy, ElementRef } from '@angular/core';
+import { LlmButtonVariant, LlmButtonSize } from '@atelier-ui/spec';
+import { FormValueControl, WithOptionalFieldTree, ValidationError, FormCheckboxControl } from '@angular/forms/signals';
+import * as _atelier_ui_angular from '@atelier-ui/angular';
+import * as i1 from '@angular/cdk/accordion';
+import * as i1$1 from '@angular/cdk/menu';
+
+/**
+ * Accessible button component with visual variants and sizes.
+ *
+ * Usage:
+ * ```html
+ * <llm-button variant="primary" size="md" (click)="save()">Save</llm-button>
+ * <llm-button variant="outline" [disabled]="true">Cancel</llm-button>
+ * <llm-button [loading]="isSaving">Saving…</llm-button>
+ * ```
+ */
+declare class LlmButton {
+    /** Visual style of the button. */
+    readonly variant: _angular_core.InputSignal<LlmButtonVariant>;
+    /** Size of the button. */
+    readonly size: _angular_core.InputSignal<LlmButtonSize>;
+    /** Disables the button, preventing interaction. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Shows a loading spinner and disables interaction. */
+    readonly loading: _angular_core.InputSignal<boolean>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmButton, "llm-button", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Card container component supporting elevated, outlined, and flat visual variants.
+ * Compose with `llm-card-header`, `llm-card-content`, and `llm-card-footer` sub-components.
+ *
+ * Usage:
+ * ```html
+ * <llm-card variant="elevated" padding="md">
+ *   <llm-card-header>Card Title</llm-card-header>
+ *   <llm-card-content>Main content goes here.</llm-card-content>
+ *   <llm-card-footer>
+ *     <llm-button variant="primary">Save</llm-button>
+ *   </llm-card-footer>
+ * </llm-card>
+ * ```
+ */
+declare class LlmCard {
+    /** Visual style of the card. */
+    readonly variant: _angular_core.InputSignal<"elevated" | "outlined" | "flat">;
+    /** Internal padding of the card. */
+    readonly padding: _angular_core.InputSignal<"sm" | "md" | "lg" | "none">;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmCard, "llm-card", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * Header slot for `llm-card`. Renders above the main content with a bottom separator.
+ *
+ * Usage:
+ * ```html
+ * <llm-card-header>Card Title</llm-card-header>
+ * ```
+ */
+declare class LlmCardHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmCardHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmCardHeader, "llm-card-header", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Content slot for `llm-card`. Primary content area of the card.
+ *
+ * Usage:
+ * ```html
+ * <llm-card-content>Body text here.</llm-card-content>
+ * ```
+ */
+declare class LlmCardContent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmCardContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmCardContent, "llm-card-content", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Footer slot for `llm-card`. Renders below the main content, typically holds actions.
+ *
+ * Usage:
+ * ```html
+ * <llm-card-footer>
+ *   <llm-button variant="primary">Save</llm-button>
+ * </llm-card-footer>
+ * ```
+ */
+declare class LlmCardFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmCardFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmCardFooter, "llm-card-footer", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Inline status badge for labeling items with semantic color variants.
+ *
+ * Usage:
+ * ```html
+ * <llm-badge variant="success">Active</llm-badge>
+ * <llm-badge variant="danger" size="sm">Error</llm-badge>
+ * <llm-badge variant="warning">Pending</llm-badge>
+ * ```
+ */
+declare class LlmBadge {
+    /** Semantic color variant of the badge. */
+    readonly variant: _angular_core.InputSignal<"default" | "success" | "warning" | "danger" | "info">;
+    /** Size of the badge. */
+    readonly size: _angular_core.InputSignal<"sm" | "md">;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmBadge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmBadge, "llm-badge", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Accessible text input component for use with Angular Signal Forms.
+ *
+ * Usage:
+ * ```html
+ * <llm-input type="email" placeholder="you@example.com" [(value)]="email" />
+ * <llm-input [formField]="loginForm.email" placeholder="Email" />
+ * ```
+ */
+declare class LlmInput implements FormValueControl<string> {
+    /** The current input value. Bound by [formField] directive. Supports [(value)] two-way binding. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** The type of input field. */
+    readonly type: _angular_core.InputSignal<"number" | "text" | "email" | "password" | "tel" | "url">;
+    /** Placeholder text shown when the input is empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Whether the input is disabled. Bound by [formField] directive. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Whether the input is read-only. Bound by [formField] directive. */
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    /** Whether the input has validation errors. Bound by [formField] directive. */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Validation errors from the form system. Bound by [formField] directive. */
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalFieldTree<ValidationError>[]>;
+    /** Whether the user has interacted with the input. Bound by [formField] directive. */
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    /** Whether the input is required. Bound by [formField] directive. */
+    readonly required: _angular_core.InputSignal<boolean>;
+    /** The input's name attribute. Bound by [formField] directive. */
+    readonly name: _angular_core.InputSignal<string>;
+    /** @internal */
+    protected readonly errorId: string;
+    /** @internal */
+    protected readonly showErrors: _angular_core.Signal<boolean>;
+    /** @internal */
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    /** @internal */
+    protected onInput(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmInput, "llm-input", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
+/**
+ * Accessible multiline text input component for use with Angular Signal Forms.
+ *
+ * Usage:
+ * ```html
+ * <llm-textarea placeholder="Enter a description" [(value)]="description" />
+ * <llm-textarea [formField]="form.bio" [rows]="4" />
+ * ```
+ */
+declare class LlmTextarea implements FormValueControl<string> {
+    /** The current textarea value. Supports [(value)] two-way binding. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Number of visible text rows. */
+    readonly rows: _angular_core.InputSignal<number>;
+    /** Placeholder text shown when the textarea is empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Whether the textarea is disabled. Bound by [formField] directive. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Whether the textarea is read-only. Bound by [formField] directive. */
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    /** Whether the textarea has validation errors. Bound by [formField] directive. */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Validation errors from the form system. Bound by [formField] directive. */
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalFieldTree<ValidationError>[]>;
+    /** Whether the user has interacted with the textarea. Bound by [formField] directive. */
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    /** Whether the textarea is required. Bound by [formField] directive. */
+    readonly required: _angular_core.InputSignal<boolean>;
+    /** The textarea's name attribute. Bound by [formField] directive. */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Whether to auto-resize the textarea height to fit its content. */
+    readonly autoResize: _angular_core.InputSignal<boolean>;
+    /** @internal */
+    protected readonly errorId: string;
+    /** @internal */
+    protected readonly showErrors: _angular_core.Signal<boolean>;
+    /** @internal */
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    /** @internal */
+    protected onInput(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmTextarea, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmTextarea, "llm-textarea", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
+/**
+ * Accessible checkbox component for use with Angular Signal Forms.
+ *
+ * Usage:
+ * ```html
+ * <llm-checkbox [(checked)]="accepted">I agree to the terms</llm-checkbox>
+ * <llm-checkbox [formField]="form.accepted">Accept</llm-checkbox>
+ * ```
+ */
+declare class LlmCheckbox implements FormCheckboxControl {
+    /** The checked state. Bound by [formField] directive. Supports [(checked)] two-way binding. */
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    /** Whether the user has interacted with the input. Bound by [formField] directive. */
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    /** Tri-state indeterminate mode (e.g. "select all"). Set via DOM property. */
+    readonly indeterminate: _angular_core.InputSignal<boolean>;
+    /** Whether the checkbox is disabled. Bound by [formField] directive. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Whether the checkbox has validation errors. Bound by [formField] directive. */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Whether the checkbox is required. Bound by [formField] directive. */
+    readonly required: _angular_core.InputSignal<boolean>;
+    /** The input's name attribute. Bound by [formField] directive. */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Validation errors from the form system. Bound by [formField] directive. */
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalFieldTree<ValidationError>[]>;
+    /** @internal */
+    protected readonly inputId: string;
+    /** @internal */
+    protected readonly errorId: string;
+    /** @internal */
+    private readonly nativeInput;
+    /** @internal */
+    protected readonly showErrors: _angular_core.Signal<boolean>;
+    /** @internal */
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    constructor();
+    /** @internal */
+    protected onChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmCheckbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmCheckbox, "llm-checkbox", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "touched": "touchedChange"; }, never, ["*"], true, never>;
+}
+
+/** @internal — shape required by LlmRadioGroup's FocusKeyManager */
+interface RadioItem {
+    focusInput(): void;
+    isDisabled(): boolean;
+    readonly radioValue: Signal<string>;
+}
+interface LlmRadioGroupContext {
+    readonly value: WritableSignal<string>;
+    readonly name: Signal<string>;
+    readonly disabled: Signal<boolean>;
+    select(v: string): void;
+    markTouched(): void;
+    registerItem(item: RadioItem): void;
+    unregisterItem(item: RadioItem): void;
+}
+declare const LLM_RADIO_GROUP: InjectionToken<LlmRadioGroupContext>;
+
+/**
+ * Individual radio button. Must be placed inside an `llm-radio-group`.
+ *
+ * Usage:
+ * ```html
+ * <llm-radio-group [(value)]="selected" name="plan">
+ *   <llm-radio radioValue="free">Free</llm-radio>
+ *   <llm-radio radioValue="pro">Pro</llm-radio>
+ * </llm-radio-group>
+ * ```
+ */
+declare class LlmRadio implements RadioItem, OnInit, OnDestroy {
+    /** The value this radio option represents within the group. */
+    readonly radioValue: _angular_core.InputSignal<string>;
+    /** Whether this specific radio is individually disabled (stacked with group disabled). */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** @internal */
+    private readonly group;
+    /** @internal */
+    private readonly el;
+    /** @internal */
+    protected readonly inputId: string;
+    /** @internal */
+    protected readonly isChecked: _angular_core.Signal<boolean>;
+    /** @internal */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    /** @internal */
+    protected readonly effectiveName: _angular_core.Signal<string>;
+    /** @internal */
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    /** @internal — for FocusKeyManager */
+    focusInput(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** @internal */
+    protected onChange(): void;
+    /** @internal */
+    protected onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmRadio, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmRadio, "llm-radio", never, { "radioValue": { "alias": "radioValue"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Container for a group of radio buttons. Manages keyboard navigation, shared name,
+ * and Signal Forms integration.
+ *
+ * Usage:
+ * ```html
+ * <llm-radio-group [(value)]="size" name="size">
+ *   <llm-radio radioValue="sm">Small</llm-radio>
+ *   <llm-radio radioValue="md">Medium</llm-radio>
+ *   <llm-radio radioValue="lg">Large</llm-radio>
+ * </llm-radio-group>
+ *
+ * <!-- With Signal Forms -->
+ * <llm-radio-group [formField]="form.size">
+ *   <llm-radio radioValue="sm">Small</llm-radio>
+ * </llm-radio-group>
+ * ```
+ */
+declare class LlmRadioGroup implements FormValueControl<string>, LlmRadioGroupContext {
+    /** The selected value. Bound by [formField] directive. Supports [(value)] two-way binding. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Whether the user has interacted. Bound by [formField] directive. */
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    /** Whether the group is disabled. Bound by [formField] directive. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Whether the group has validation errors. Bound by [formField] directive. */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Whether the group is required. Bound by [formField] directive. */
+    readonly required: _angular_core.InputSignal<boolean>;
+    /** Shared name attribute propagated to all child radio inputs. Bound by [formField] directive. */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Validation errors from the form system. Bound by [formField] directive. */
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalFieldTree<ValidationError>[]>;
+    /** @internal */
+    protected readonly errorId: string;
+    /** @internal */
+    private readonly items;
+    /** @internal */
+    protected readonly showErrors: _angular_core.Signal<boolean>;
+    /** @internal */
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    /** @internal — called by LlmRadio on change */
+    select(v: string): void;
+    /** @internal — called by LlmRadio on blur */
+    markTouched(): void;
+    /** @internal — called by LlmRadio on init */
+    registerItem(item: RadioItem): void;
+    /** @internal — called by LlmRadio on destroy */
+    unregisterItem(item: RadioItem): void;
+    /** @internal */
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmRadioGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmRadioGroup, "llm-radio-group", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Accessible toggle (switch) component for use with Angular Signal Forms.
+ * Presents as a pill-shaped on/off slider instead of a checkbox box,
+ * but has identical boolean semantics and implements FormCheckboxControl.
+ *
+ * Usage:
+ * ```html
+ * <llm-toggle [(checked)]="enabled">Enable notifications</llm-toggle>
+ * <llm-toggle [formField]="form.enabled">Enable</llm-toggle>
+ * ```
+ */
+declare class LlmToggle implements FormCheckboxControl {
+    /** The checked state. Bound by [formField] directive. Supports [(checked)] two-way binding. */
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    /** Whether the user has interacted with the input. Bound by [formField] directive. */
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    /** Whether the toggle is disabled. Bound by [formField] directive. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Whether the toggle has validation errors. Bound by [formField] directive. */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Whether the toggle is required. Bound by [formField] directive. */
+    readonly required: _angular_core.InputSignal<boolean>;
+    /** The input's name attribute. Bound by [formField] directive. */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Validation errors from the form system. Bound by [formField] directive. */
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalFieldTree<ValidationError>[]>;
+    /** @internal */
+    protected readonly inputId: string;
+    /** @internal */
+    protected readonly errorId: string;
+    /** @internal */
+    protected readonly showErrors: _angular_core.Signal<boolean>;
+    /** @internal */
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    /** @internal */
+    protected onChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmToggle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmToggle, "llm-toggle", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "touched": "touchedChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Inline notification banner with semantic color variants and optional dismiss button.
+ *
+ * Usage:
+ * ```html
+ * <llm-alert variant="success">Your changes were saved.</llm-alert>
+ * <llm-alert variant="warning" [dismissible]="true" (dismissed)="onDismiss()">
+ *   Your session expires soon.
+ * </llm-alert>
+ * ```
+ */
+declare class LlmAlert {
+    /** Semantic color variant of the alert. */
+    readonly variant: _angular_core.InputSignal<"success" | "warning" | "danger" | "info">;
+    /** Whether to show a dismiss button. */
+    readonly dismissible: _angular_core.InputSignal<boolean>;
+    /** Emitted when the dismiss button is clicked. */
+    readonly dismissed: _angular_core.OutputEmitterRef<void>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    /** @internal */
+    get isDismissible(): boolean;
+    /** @internal */
+    get hostClassesValue(): string;
+    /** @internal */
+    get ariaLive(): string;
+    protected dismiss(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmAlert, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmAlert, "llm-alert", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, ["*"], true, never>;
+}
+
+interface LlmSelectContext {
+    readonly value: WritableSignal<string>;
+    readonly disabled: Signal<boolean>;
+    readonly activeOptionId: WritableSignal<string | null>;
+    select(v: string): void;
+    markTouched(): void;
+    registerOption(id: string, value: string, labelText: string, disabled: boolean): void;
+    unregisterOption(id: string): void;
+}
+declare const LLM_SELECT: InjectionToken<LlmSelectContext>;
+
+/**
+ * Accessible dropdown select component for use with Angular Signal Forms.
+ * Uses the native Popover API for the panel overlay.
+ *
+ * Usage:
+ * ```html
+ * <llm-select [(value)]="country" placeholder="Select a country">
+ *   <llm-option optionValue="us">United States</llm-option>
+ *   <llm-option optionValue="ca">Canada</llm-option>
+ * </llm-select>
+ *
+ * <!-- With Signal Forms -->
+ * <llm-select [formField]="form.country" placeholder="Select a country">
+ *   <llm-option optionValue="us">United States</llm-option>
+ * </llm-select>
+ * ```
+ */
+declare class LlmSelect implements FormValueControl<string>, LlmSelectContext {
+    /** The selected value. Bound by [formField] directive. Supports [(value)] two-way binding. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Whether the user has interacted. Bound by [formField] directive. */
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    /** Placeholder text shown when no option is selected. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Whether the select is disabled. Bound by [formField] directive. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Whether the select has validation errors. Bound by [formField] directive. */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Whether the select is required. Bound by [formField] directive. */
+    readonly required: _angular_core.InputSignal<boolean>;
+    /** The input's name attribute. Bound by [formField] directive. */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Validation errors from the form system. Bound by [formField] directive. */
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalFieldTree<ValidationError>[]>;
+    /** @internal */
+    readonly activeOptionId: _angular_core.WritableSignal<string | null>;
+    /** @internal */
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    /** @internal */
+    protected readonly optionsList: _angular_core.WritableSignal<{
+        id: string;
+        value: string;
+        labelText: string;
+        disabled: boolean;
+    }[]>;
+    /** @internal */
+    protected readonly panelRef: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    /** @internal */
+    protected readonly triggerId: string;
+    /** @internal */
+    protected readonly panelId: string;
+    /** @internal */
+    protected readonly errorId: string;
+    /** @internal */
+    protected readonly selectedLabel: _angular_core.Signal<string>;
+    /** @internal */
+    protected readonly showErrors: _angular_core.Signal<boolean>;
+    /** @internal */
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    /** @internal */
+    private keyManager;
+    private outsideClickHandler;
+    private readonly elementRef;
+    /** @internal — called by LlmOption on init */
+    registerOption(id: string, value: string, labelText: string, disabled: boolean): void;
+    /** @internal — called by LlmOption on destroy */
+    unregisterOption(id: string): void;
+    /** @internal — called by LlmOption on select */
+    select(v: string): void;
+    /** @internal — called by LlmOption on interaction */
+    markTouched(): void;
+    /** @internal */
+    protected onTriggerClick(): void;
+    /** @internal */
+    protected onTriggerBlur(): void;
+    /** @internal */
+    protected onPanelToggle(event: Event): void;
+    /** @internal */
+    protected onKeydown(event: KeyboardEvent): void;
+    private open;
+    private close;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmSelect, "llm-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Option item for use inside `<llm-select>`.
+ *
+ * Usage:
+ * ```html
+ * <llm-option optionValue="us">United States</llm-option>
+ * ```
+ */
+declare class LlmOption implements OnInit, OnDestroy {
+    /** The value this option represents. Required. */
+    readonly optionValue: _angular_core.InputSignal<string>;
+    /** Whether this option is disabled. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** @internal */
+    protected readonly optionId: string;
+    /** @internal */
+    private readonly context;
+    /** @internal */
+    private readonly elementRef;
+    /** @internal */
+    protected readonly isSelected: _angular_core.Signal<boolean>;
+    /** @internal */
+    protected readonly isActive: _angular_core.Signal<boolean>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** @internal */
+    protected onClick(): void;
+    /** @internal */
+    protected onMouseEnter(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmOption, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmOption, "llm-option", never, { "optionValue": { "alias": "optionValue"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Accessible modal dialog using the native `<dialog>` element.
+ * Includes focus trap, Escape to close, backdrop click to close, and animation.
+ * Compose with `llm-dialog-header`, `llm-dialog-content`, and `llm-dialog-footer`.
+ *
+ * Usage:
+ * ```html
+ * <llm-dialog [(open)]="isOpen">
+ *   <llm-dialog-header>Dialog Title</llm-dialog-header>
+ *   <llm-dialog-content>Dialog body content.</llm-dialog-content>
+ *   <llm-dialog-footer>
+ *     <llm-button variant="primary" (click)="isOpen = false">Confirm</llm-button>
+ *   </llm-dialog-footer>
+ * </llm-dialog>
+ * ```
+ */
+declare class LlmDialog {
+    /** Whether the dialog is open. Supports two-way binding: [(open)]="isOpen". */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** Whether clicking the backdrop closes the dialog. */
+    readonly closeOnBackdrop: _angular_core.InputSignal<boolean>;
+    /** Size of the dialog panel. */
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | "xl" | "full">;
+    /** Accessible label for the dialog (use instead of aria-labelledby when no header is present). */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** ID of the element that labels the dialog (defaults to the llm-dialog-header id). */
+    readonly ariaLabelledby: _angular_core.InputSignal<string>;
+    /** @internal — referenced by LlmDialogHeader via LLM_DIALOG token */
+    readonly headerId: string;
+    protected readonly dialogId: string;
+    protected readonly dialogRef: _angular_core.Signal<ElementRef<HTMLDialogElement> | undefined>;
+    private readonly triggerEl;
+    protected readonly panelClass: _angular_core.Signal<string>;
+    protected readonly hostClasses: _angular_core.Signal<"" | "is-open">;
+    constructor();
+    protected onCancel(event: Event): void;
+    protected onBackdropClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmDialog, "llm-dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["*"], true, never>;
+}
+/**
+ * Header slot for `llm-dialog`. Renders above content with a bottom separator.
+ * Automatically receives the correct `id` for `aria-labelledby` association.
+ */
+declare class LlmDialogHeader {
+    protected readonly context: _atelier_ui_angular.LlmDialogContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmDialogHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmDialogHeader, "llm-dialog-header", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Content slot for `llm-dialog`. Scrollable primary content area.
+ */
+declare class LlmDialogContent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmDialogContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmDialogContent, "llm-dialog-content", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Footer slot for `llm-dialog`. Renders below content, typically holds action buttons.
+ */
+declare class LlmDialogFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmDialogFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmDialogFooter, "llm-dialog-footer", never, {}, {}, never, ["*"], true, never>;
+}
+
+interface LlmDialogContext {
+    headerId: string;
+    close: () => void;
+}
+declare const LLM_DIALOG: InjectionToken<LlmDialogContext>;
+
+interface TabInfo {
+    id: string;
+    label: string;
+    disabled: boolean;
+    panelId: string;
+    tabId: string;
+}
+interface LlmTabGroupContext {
+    readonly selectedIndex: WritableSignal<number>;
+    readonly tabs: Signal<TabInfo[]>;
+    registerTab(info: TabInfo): void;
+    unregisterTab(id: string): void;
+}
+declare const LLM_TAB_GROUP: InjectionToken<LlmTabGroupContext>;
+
+/**
+ * Accessible tabbed interface container. Renders a tab list and manages
+ * keyboard navigation with roving tabindex.
+ *
+ * Usage:
+ * ```html
+ * <llm-tab-group [(selectedIndex)]="activeTab">
+ *   <llm-tab label="Account">Account settings here.</llm-tab>
+ *   <llm-tab label="Notifications">Notification prefs here.</llm-tab>
+ *   <llm-tab label="Billing" [disabled]="true">Billing info here.</llm-tab>
+ * </llm-tab-group>
+ * ```
+ */
+declare class LlmTabGroup implements LlmTabGroupContext {
+    /** Index of the currently active tab. Supports two-way binding. */
+    readonly selectedIndex: _angular_core.ModelSignal<number>;
+    /** Visual variant. */
+    readonly variant: _angular_core.InputSignal<"default" | "pills">;
+    /** @internal */
+    readonly tabs: _angular_core.WritableSignal<TabInfo[]>;
+    /** @internal */
+    private readonly elementRef;
+    /** @internal */
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    /** @internal — called by LlmTab on init */
+    registerTab(info: TabInfo): void;
+    /** @internal — called by LlmTab on destroy */
+    unregisterTab(id: string): void;
+    /** @internal */
+    protected selectTab(index: number): void;
+    /** @internal */
+    protected onTabKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmTabGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmTabGroup, "llm-tab-group", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; }, never, ["*"], true, never>;
+}
+/**
+ * Individual tab definition. Place inside `<llm-tab-group>`.
+ *
+ * Usage:
+ * ```html
+ * <llm-tab label="Settings">Settings content here.</llm-tab>
+ * ```
+ */
+declare class LlmTab implements OnInit, OnDestroy {
+    /** Text displayed on the tab button. Required. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Whether this tab is disabled. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** @internal */
+    readonly tabId: string;
+    /** @internal */
+    readonly panelId: string;
+    /** @internal */
+    private readonly id;
+    /** @internal */
+    private readonly context;
+    /** @internal */
+    protected readonly isActive: _angular_core.Signal<boolean>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmTab, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmTab, "llm-tab", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** @internal — shape required by LlmAccordionGroup's FocusKeyManager */
+interface AccordionItem {
+    readonly id: string;
+    focusTrigger(): void;
+    isItemDisabled(): boolean;
+}
+interface LlmAccordionGroupContext {
+    register(item: AccordionItem): void;
+    unregister(item: AccordionItem): void;
+    handleKeydown(event: KeyboardEvent, item: AccordionItem): void;
+}
+declare const LLM_ACCORDION_GROUP: InjectionToken<LlmAccordionGroupContext>;
+
+/**
+ * Container that manages accordion items. Controls single vs multi expansion
+ * and provides keyboard navigation across items.
+ *
+ * Usage:
+ * ```html
+ * <llm-accordion-group [multi]="true" variant="separated">
+ *   <llm-accordion-item [(expanded)]="open">
+ *     <span llmAccordionHeader>Title</span>
+ *     Body content here.
+ *   </llm-accordion-item>
+ * </llm-accordion-group>
+ * ```
+ */
+declare class LlmAccordionGroup implements LlmAccordionGroupContext {
+    /** Allow multiple items to be expanded simultaneously. */
+    readonly multi: _angular_core.InputSignal<boolean>;
+    /** Visual variant. */
+    readonly variant: _angular_core.InputSignal<"default" | "bordered" | "separated">;
+    /** @internal */
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    /** @internal */
+    get hostClassesValue(): string;
+    /** @internal */
+    private readonly items;
+    register(item: AccordionItem): void;
+    unregister(item: AccordionItem): void;
+    handleKeydown(event: KeyboardEvent, item: AccordionItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmAccordionGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmAccordionGroup, "llm-accordion-group", never, { "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.CdkAccordion; inputs: { "multi": "multi"; }; outputs: {}; }]>;
+}
+/**
+ * Directive to mark the accordion header content.
+ */
+declare class LlmAccordionHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmAccordionHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LlmAccordionHeader, "[llmAccordionHeader]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Individual collapsible accordion item. Place inside `<llm-accordion-group>`.
+ *
+ * Usage:
+ * ```html
+ * <llm-accordion-item [(expanded)]="isOpen">
+ *   <span llmAccordionHeader>Section Title</span>
+ *   Section content goes here.
+ * </llm-accordion-item>
+ * ```
+ */
+declare class LlmAccordionItem implements AccordionItem, OnInit, OnDestroy {
+    /** Whether this item is expanded. Supports two-way binding. */
+    readonly expanded: _angular_core.ModelSignal<boolean>;
+    /** Whether this item is disabled. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** @internal */
+    readonly id: string;
+    /** @internal */
+    readonly triggerId: string;
+    /** @internal */
+    readonly panelId: string;
+    /** @internal */
+    private readonly group;
+    /** @internal */
+    private readonly cdkItem;
+    /** @internal */
+    private readonly el;
+    /** @internal */
+    protected readonly isExpanded: _angular_core.WritableSignal<boolean>;
+    /** @internal */
+    get isExpandedValue(): boolean;
+    /** @internal */
+    get isDisabled(): boolean;
+    /** @internal */
+    get ariaDisabled(): boolean | null;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** @internal — for FocusKeyManager */
+    focusTrigger(): void;
+    /** @internal — for FocusKeyManager */
+    isItemDisabled(): boolean;
+    /** @internal */
+    protected onToggle(): void;
+    /** @internal */
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmAccordionItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmAccordionItem, "llm-accordion-item", never, { "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, never, ["[llmAccordionHeader]", "*"], true, [{ directive: typeof i1.CdkAccordionItem; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Trigger directive that opens an `<llm-menu>` dropdown.
+ * Apply to any element (typically `<llm-button>`) to wire up click + keyboard open/close.
+ *
+ * Usage:
+ * ```html
+ * <llm-button [llmMenuTriggerFor]="myMenu">Open</llm-button>
+ * <ng-template #myMenu>
+ *   <llm-menu>
+ *     <llm-menu-item (triggered)="action()">Action</llm-menu-item>
+ *   </llm-menu>
+ * </ng-template>
+ * ```
+ */
+declare class LlmMenuTrigger {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmMenuTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LlmMenuTrigger, "[llmMenuTriggerFor]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.CdkMenuTrigger; inputs: { "cdkMenuTriggerFor": "llmMenuTriggerFor"; }; outputs: {}; }]>;
+}
+/**
+ * Accessible dropdown menu panel.
+ * Uses `@angular/cdk/menu` for keyboard navigation, focus management, and ARIA.
+ *
+ * Usage:
+ * ```html
+ * <llm-button [llmMenuTriggerFor]="actions">Actions</llm-button>
+ * <ng-template #actions>
+ *   <llm-menu>
+ *     <llm-menu-item (triggered)="onCopy()">Copy</llm-menu-item>
+ *     <llm-menu-separator />
+ *     <llm-menu-item [disabled]="true">Paste</llm-menu-item>
+ *   </llm-menu>
+ * </ng-template>
+ * ```
+ */
+declare class LlmMenu {
+    /** Visual variant. `compact` reduces font size and padding. */
+    readonly variant: _angular_core.InputSignal<"default" | "compact">;
+    /** @internal */
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmMenu, "llm-menu", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1$1.CdkMenu; inputs: {}; outputs: {}; }]>;
+}
+/**
+ * A single item inside an `<llm-menu>`.
+ * Supports keyboard navigation, disabled state, and nested submenus via `[llmMenuTriggerFor]`.
+ *
+ * Usage:
+ * ```html
+ * <llm-menu-item (triggered)="doSomething()">Label</llm-menu-item>
+ * <llm-menu-item [disabled]="true">Disabled</llm-menu-item>
+ * ```
+ */
+declare class LlmMenuItem {
+    /** Whether this menu item is disabled. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** @internal — detect if this item also triggers a submenu */
+    private readonly menuTrigger;
+    /** @internal */
+    protected readonly hasSubmenu: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmMenuItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmMenuItem, "llm-menu-item", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1$1.CdkMenuItem; inputs: { "cdkMenuItemDisabled": "disabled"; }; outputs: { "cdkMenuItemTriggered": "triggered"; }; }]>;
+}
+/**
+ * Visual separator between groups of menu items.
+ *
+ * Usage:
+ * ```html
+ * <llm-menu-item>Copy</llm-menu-item>
+ * <llm-menu-separator />
+ * <llm-menu-item>Delete</llm-menu-item>
+ * ```
+ */
+declare class LlmMenuSeparator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmMenuSeparator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmMenuSeparator, "llm-menu-separator", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Attribute directive that displays a text tooltip on hover or focus.
+ * Uses `@angular/cdk/overlay` for viewport-aware positioning.
+ *
+ * Usage:
+ * ```html
+ * <llm-button llmTooltip="Save your changes">Save</llm-button>
+ * <llm-button llmTooltip="Copy to clipboard" llmTooltipPosition="right">Copy</llm-button>
+ * ```
+ */
+declare class LlmTooltip implements OnDestroy {
+    /** The tooltip text. */
+    readonly llmTooltip: _angular_core.InputSignal<string>;
+    /** Preferred tooltip placement. Falls back to the opposite side if clipped. */
+    readonly llmTooltipPosition: _angular_core.InputSignal<"above" | "below" | "left" | "right">;
+    /** Disable the tooltip without removing the directive. */
+    readonly llmTooltipDisabled: _angular_core.InputSignal<boolean>;
+    /** Delay in ms before the tooltip appears. */
+    readonly llmTooltipShowDelay: _angular_core.InputSignal<number>;
+    /** Delay in ms before the tooltip hides. */
+    readonly llmTooltipHideDelay: _angular_core.InputSignal<number>;
+    private readonly injector;
+    private readonly elementRef;
+    private overlayRef;
+    private showTimer;
+    private hideTimer;
+    /** @internal — links host aria-describedby to the tooltip element */
+    protected readonly activeTooltipId: _angular_core.WritableSignal<string | null>;
+    /** @internal */
+    protected show(): void;
+    /** @internal */
+    protected hide(): void;
+    ngOnDestroy(): void;
+    private attach;
+    private createOverlay;
+    private clearShowTimer;
+    private clearHideTimer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LlmTooltip, "[llmTooltip]", never, { "llmTooltip": { "alias": "llmTooltip"; "required": true; "isSignal": true; }; "llmTooltipPosition": { "alias": "llmTooltipPosition"; "required": false; "isSignal": true; }; "llmTooltipDisabled": { "alias": "llmTooltipDisabled"; "required": false; "isSignal": true; }; "llmTooltipShowDelay": { "alias": "llmTooltipShowDelay"; "required": false; "isSignal": true; }; "llmTooltipHideDelay": { "alias": "llmTooltipHideDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Loading placeholder that mimics the shape of content while it loads.
+ *
+ * Usage:
+ * ```html
+ * <llm-skeleton />
+ * <llm-skeleton variant="circular" width="40px" />
+ * <llm-skeleton variant="rectangular" height="200px" />
+ * ```
+ */
+declare class LlmSkeleton {
+    /** Shape variant of the skeleton placeholder. */
+    readonly variant: _angular_core.InputSignal<"text" | "circular" | "rectangular">;
+    /** CSS width of the skeleton. */
+    readonly width: _angular_core.InputSignal<string>;
+    /** CSS height — when empty, a sensible default is chosen per variant. */
+    readonly height: _angular_core.InputSignal<string>;
+    /** Whether the shimmer animation is active. */
+    readonly animated: _angular_core.InputSignal<boolean>;
+    protected readonly computedHeight: _angular_core.Signal<string>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmSkeleton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmSkeleton, "llm-skeleton", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "animated": { "alias": "animated"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Variant types for toast notifications. */
+type ToastVariant = 'default' | 'success' | 'warning' | 'danger' | 'info';
+/** Options for creating a toast notification. */
+interface ToastOptions {
+    variant?: ToastVariant;
+    /** Duration in ms before auto-dismiss. 0 = no auto-dismiss. Default 5000. */
+    duration?: number;
+    /** Whether the toast shows a dismiss button. Default true. */
+    dismissible?: boolean;
+}
+/** Internal data for a toast instance. */
+interface ToastData {
+    id: string;
+    message: string;
+    variant: ToastVariant;
+    duration: number;
+    dismissible: boolean;
+}
+/**
+ * Service for showing transient toast notifications.
+ *
+ * Usage:
+ * ```typescript
+ * const toast = inject(LlmToastService);
+ * toast.show('Saved successfully', { variant: 'success' });
+ * ```
+ */
+declare class LlmToastService {
+    readonly toasts: _angular_core.WritableSignal<ToastData[]>;
+    private readonly timers;
+    /**
+     * Show a toast notification.
+     * @returns The unique id of the toast, which can be used with `dismiss()`.
+     */
+    show(message: string, options?: ToastOptions): string;
+    /** Dismiss a single toast by id. */
+    dismiss(id: string): void;
+    /** Clear all active toasts. */
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LlmToastService>;
+}
+/**
+ * Individual toast notification.
+ *
+ * Typically rendered by `llm-toast-container`, but can also be used standalone.
+ */
+declare class LlmToast {
+    /** Semantic color variant. */
+    readonly variant: _angular_core.InputSignal<ToastVariant>;
+    /** Whether to show a dismiss button. */
+    readonly dismissible: _angular_core.InputSignal<boolean>;
+    /** The message to display. */
+    readonly message: _angular_core.InputSignal<string>;
+    /** Unique identifier for this toast. */
+    readonly toastId: _angular_core.InputSignal<string>;
+    /** Emitted when the toast is dismissed by the user. */
+    readonly dismissed: _angular_core.OutputEmitterRef<string>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    protected onDismiss(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmToast, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmToast, "llm-toast", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "toastId": { "alias": "toastId"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, never, true, never>;
+}
+/**
+ * Container that renders the toast stack at a fixed viewport position.
+ * Place once in your app root or layout component.
+ *
+ * Usage:
+ * ```html
+ * <llm-toast-container position="bottom-right" />
+ * ```
+ */
+declare class LlmToastContainer {
+    protected readonly toastService: LlmToastService;
+    private readonly destroyRef;
+    /** Position of the toast stack on the viewport. */
+    readonly position: _angular_core.InputSignal<"top-right" | "top-center" | "bottom-right" | "bottom-center">;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmToastContainer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmToastContainer, "llm-toast-container", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Displays a user avatar with image, initials, or icon fallback.
+ *
+ * Fallback order: image → initials (from `name`) → generic icon.
+ *
+ * Usage:
+ * ```html
+ * <llm-avatar src="https://example.com/photo.jpg" name="Jane Doe" />
+ * <llm-avatar name="John Smith" size="lg" status="online" />
+ * <llm-avatar size="sm" shape="square" />
+ * ```
+ */
+declare class LlmAvatar {
+    /** Image URL. Falls back to initials or icon if empty or fails to load. */
+    readonly src: _angular_core.InputSignal<string>;
+    /** Alt text for the image (also used as aria-label). */
+    readonly alt: _angular_core.InputSignal<string>;
+    /** Full name used to generate initials fallback and default aria-label. */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Size of the avatar. */
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | "xl" | "xs">;
+    /** Shape of the avatar. */
+    readonly shape: _angular_core.InputSignal<"circle" | "square">;
+    /** Presence status indicator dot. Empty string hides the dot. */
+    readonly status: _angular_core.InputSignal<"" | "online" | "offline" | "away" | "busy">;
+    /** @internal — reset to true whenever src changes */
+    protected readonly showImage: _angular_core.WritableSignal<boolean>;
+    /** @internal */
+    protected readonly initials: _angular_core.Signal<string>;
+    /** @internal */
+    protected readonly ariaLabel: _angular_core.Signal<string>;
+    /** @internal */
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmAvatar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmAvatar, "llm-avatar", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Groups multiple avatars with overlap and an overflow count badge.
+ *
+ * Usage:
+ * ```html
+ * <llm-avatar-group [max]="3" size="md">
+ *   <llm-avatar name="Alice" />
+ *   <llm-avatar name="Bob" />
+ *   <llm-avatar name="Charlie" />
+ *   <llm-avatar name="Dave" />
+ * </llm-avatar-group>
+ * ```
+ */
+declare class LlmAvatarGroup {
+    /** Maximum visible avatars before showing an overflow count. */
+    readonly max: _angular_core.InputSignal<number>;
+    /** Size applied to the overflow badge (match the size used on child avatars). */
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | "xl" | "xs">;
+    private readonly avatarEls;
+    protected readonly overflowCount: _angular_core.Signal<number>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmAvatarGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmAvatarGroup, "llm-avatar-group", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, ["avatarEls"], ["*"], true, never>;
+}
+
+/**
+ * Progress bar with determinate and indeterminate states.
+ *
+ * Usage:
+ * ```html
+ * <llm-progress [value]="75" />
+ * <llm-progress variant="success" [value]="100" />
+ * <llm-progress [indeterminate]="true" />
+ * ```
+ */
+declare class LlmProgress {
+    /** Current value of the progress bar. */
+    readonly value: _angular_core.InputSignal<number>;
+    /** Maximum value. */
+    readonly max: _angular_core.InputSignal<number>;
+    /** Semantic color variant. */
+    readonly variant: _angular_core.InputSignal<"default" | "success" | "warning" | "danger">;
+    /** Height size of the track. */
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    /** Shows an animated indeterminate state (loading). */
+    readonly indeterminate: _angular_core.InputSignal<boolean>;
+    protected readonly clampedValue: _angular_core.Signal<number>;
+    protected readonly fillWidth: _angular_core.Signal<string>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmProgress, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmProgress, "llm-progress", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Accessible breadcrumb navigation. Wrap `llm-breadcrumb-item` elements inside.
+ * The last item is automatically marked as the current page.
+ *
+ * Usage:
+ * ```html
+ * <llm-breadcrumbs>
+ *   <llm-breadcrumb-item href="/home">Home</llm-breadcrumb-item>
+ *   <llm-breadcrumb-item href="/products">Products</llm-breadcrumb-item>
+ *   <llm-breadcrumb-item>Widget X</llm-breadcrumb-item>
+ * </llm-breadcrumbs>
+ * ```
+ */
+declare class LlmBreadcrumbs {
+    private readonly _itemIds;
+    private _nextId;
+    /** @internal — used by LlmBreadcrumbItem via LLM_BREADCRUMBS token */
+    readonly lastItemId: _angular_core.Signal<number>;
+    /** @internal */
+    registerItem(): number;
+    /** @internal */
+    unregisterItem(id: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmBreadcrumbs, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmBreadcrumbs, "llm-breadcrumbs", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * A single breadcrumb step. The last item is automatically treated as
+ * `aria-current="page"` and rendered as plain text (no link).
+ */
+declare class LlmBreadcrumbItem implements OnInit, OnDestroy {
+    /** Optional href for navigation. Ignored on the last (current) item. */
+    readonly href: _angular_core.InputSignal<string>;
+    private readonly context;
+    private readonly myIndex;
+    protected readonly isCurrent: _angular_core.Signal<boolean>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmBreadcrumbItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmBreadcrumbItem, "llm-breadcrumb-item", never, { "href": { "alias": "href"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface LlmBreadcrumbsContext {
+    registerItem(): number;
+    unregisterItem(id: number): void;
+    readonly lastItemId: Signal<number>;
+}
+declare const LLM_BREADCRUMBS: InjectionToken<LlmBreadcrumbsContext>;
+
+type PageItem = {
+    type: 'page';
+    page: number;
+} | {
+    type: 'ellipsis';
+    key: string;
+};
+/**
+ * Pagination control for navigating multi-page content.
+ *
+ * Usage:
+ * ```html
+ * <llm-pagination [(page)]="currentPage" [pageCount]="totalPages" />
+ * ```
+ */
+declare class LlmPagination {
+    /** Current page (1-based). Supports two-way binding: [(page)]="currentPage". */
+    readonly page: _angular_core.ModelSignal<number>;
+    /** Total number of pages. */
+    readonly pageCount: _angular_core.InputSignal<number>;
+    /** Number of page buttons to show on each side of the current page. */
+    readonly siblingCount: _angular_core.InputSignal<number>;
+    /** Whether to show first/last page jump buttons. */
+    readonly showFirstLast: _angular_core.InputSignal<boolean>;
+    protected readonly pageItems: _angular_core.Signal<PageItem[]>;
+    protected goTo(p: number): void;
+    protected goPrev(): void;
+    protected goNext(): void;
+    protected goFirst(): void;
+    protected goLast(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmPagination, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmPagination, "llm-pagination", never, { "page": { "alias": "page"; "required": false; "isSignal": true; }; "pageCount": { "alias": "pageCount"; "required": false; "isSignal": true; }; "siblingCount": { "alias": "siblingCount"; "required": false; "isSignal": true; }; "showFirstLast": { "alias": "showFirstLast"; "required": false; "isSignal": true; }; }, { "page": "pageChange"; }, never, never, true, never>;
+}
+
+/**
+ * Slide-in drawer panel using the native `<dialog>` element.
+ * Supports left, right, top, and bottom positions with focus trap,
+ * Escape to close, and backdrop click to close.
+ * Compose with `llm-drawer-header`, `llm-drawer-content`, and `llm-drawer-footer`.
+ *
+ * Usage:
+ * ```html
+ * <llm-button (click)="isOpen = true">Open</llm-button>
+ * <llm-drawer [(open)]="isOpen" position="right">
+ *   <llm-drawer-header>Settings</llm-drawer-header>
+ *   <llm-drawer-content>Content here.</llm-drawer-content>
+ *   <llm-drawer-footer>
+ *     <llm-button variant="primary" (click)="isOpen = false">Save</llm-button>
+ *   </llm-drawer-footer>
+ * </llm-drawer>
+ * ```
+ */
+declare class LlmDrawer {
+    /** Whether the drawer is open. Supports two-way binding: [(open)]="isOpen". */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** Which edge the drawer slides in from. */
+    readonly position: _angular_core.InputSignal<"top" | "bottom" | "left" | "right">;
+    /** Width (for left/right) or height (for top/bottom) of the panel. */
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | "full">;
+    /** Whether clicking the backdrop closes the drawer. */
+    readonly closeOnBackdrop: _angular_core.InputSignal<boolean>;
+    /** @internal — referenced by LlmDrawerHeader via LLM_DRAWER token */
+    readonly headerId: string;
+    protected readonly drawerId: string;
+    protected readonly dialogRef: _angular_core.Signal<ElementRef<HTMLDialogElement> | undefined>;
+    private readonly triggerEl;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    constructor();
+    protected onCancel(event: Event): void;
+    protected onBackdropClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmDrawer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmDrawer, "llm-drawer", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["*"], true, never>;
+}
+/**
+ * Header slot for `llm-drawer`. Contains the title and a close button.
+ * Automatically receives the correct `id` for `aria-labelledby` association.
+ */
+declare class LlmDrawerHeader {
+    protected readonly context: _atelier_ui_angular.LlmDrawerContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmDrawerHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmDrawerHeader, "llm-drawer-header", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Content slot for `llm-drawer`. Scrollable primary content area.
+ */
+declare class LlmDrawerContent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmDrawerContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmDrawerContent, "llm-drawer-content", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Footer slot for `llm-drawer`. Renders at the bottom with action buttons.
+ */
+declare class LlmDrawerFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LlmDrawerFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LlmDrawerFooter, "llm-drawer-footer", never, {}, {}, never, ["*"], true, never>;
+}
+
+interface LlmDrawerContext {
+    headerId: string;
+    close: () => void;
+}
+declare const LLM_DRAWER: InjectionToken<LlmDrawerContext>;
+
+export { LLM_ACCORDION_GROUP, LLM_BREADCRUMBS, LLM_DIALOG, LLM_DRAWER, LLM_RADIO_GROUP, LLM_SELECT, LLM_TAB_GROUP, LlmAccordionGroup, LlmAccordionHeader, LlmAccordionItem, LlmAlert, LlmAvatar, LlmAvatarGroup, LlmBadge, LlmBreadcrumbItem, LlmBreadcrumbs, LlmButton, LlmCard, LlmCardContent, LlmCardFooter, LlmCardHeader, LlmCheckbox, LlmDialog, LlmDialogContent, LlmDialogFooter, LlmDialogHeader, LlmDrawer, LlmDrawerContent, LlmDrawerFooter, LlmDrawerHeader, LlmInput, LlmMenu, LlmMenuItem, LlmMenuSeparator, LlmMenuTrigger, LlmOption, LlmPagination, LlmProgress, LlmRadio, LlmRadioGroup, LlmSelect, LlmSkeleton, LlmTab, LlmTabGroup, LlmTextarea, LlmToast, LlmToastContainer, LlmToastService, LlmToggle, LlmTooltip };
+export type { LlmAccordionGroupContext, LlmBreadcrumbsContext, LlmDialogContext, LlmDrawerContext, LlmRadioGroupContext, LlmSelectContext, LlmTabGroupContext, PageItem, TabInfo, ToastData, ToastOptions };