@andes-ng/primitives 0.0.0-stage → 0.1.0-rc.2

package/types/andes-ng-primitives.d.ts

@@ -0,0 +1,3018 @@
+import * as _angular_core from '@angular/core';
+import { Signal, OnInit, OnDestroy, WritableSignal, InjectionToken, Injector, ElementRef, Type, Provider, TemplateRef, ViewContainerRef } from '@angular/core';
+import * as _andes_ng_primitives from '@andes-ng/primitives';
+import { Observable } from 'rxjs';
+import { ValidationErrors, ControlValueAccessor } from '@angular/forms';
+import { ComponentType, ConnectedPosition, PositionStrategy } from '@angular/cdk/overlay';
+
+declare class AndesButtonPrimitive {
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly isAnchor: boolean;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesButtonPrimitive, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AndesButtonPrimitive, "button[andesButtonPrimitive], a[andesButtonPrimitive]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Which arrow keys move the active item.
+ *
+ * - `vertical` — `ArrowUp`/`ArrowDown` (Select and Dropdown Menu listboxes, Combobox popups).
+ * - `horizontal` — `ArrowLeft`/`ArrowRight`, mirrored for RTL (a horizontal `Tabs` tablist).
+ * - `both` — every arrow key moves through the same flat list (grid-ish toolbars, wrapping
+ *   chip rows). There is no two-dimensional row/column model here: `both` simply means all
+ *   four arrow keys walk the one list.
+ */
+type AndesListOrientation = 'vertical' | 'horizontal' | 'both';
+/**
+ * How the active item is surfaced to assistive technology.
+ *
+ * - `roving-tabindex` — the items are genuinely focusable and real DOM focus moves between
+ *   them; exactly one item carries `tabindex="0"` while the rest carry `tabindex="-1"`.
+ *   Use this whenever the container itself is not a text input: Dropdown Menu and Tabs.
+ * - `active-descendant` — real DOM focus never leaves one element (typically a text
+ *   `<input>`); the active item is communicated purely through `aria-activedescendant`
+ *   pointing at that item's `id`, and items get no `tabindex` at all.
+ *   Use this for Combobox, whose input must keep focus while the user navigates the popup.
+ */
+type AndesListFocusMode = 'roving-tabindex' | 'active-descendant';
+/** Text direction used to mirror horizontal arrow keys. */
+type AndesListTextDirection = 'ltr' | 'rtl';
+/**
+ * Options accepted by {@link AndesListNavigation.configure}. Every key is optional; an
+ * omitted key leaves the current value untouched, so `configure` is safe to call from an
+ * `effect` that only knows about some of the options.
+ */
+interface AndesListNavigationConfig {
+    /** Which arrow keys navigate. Default `'vertical'`. */
+    orientation?: AndesListOrientation;
+    /**
+     * Whether navigation wraps around the ends of the list. Default `true` (the WAI-ARIA
+     * Tabs and Menu convention). Set to `false` for listboxes that should stop at the
+     * first/last option instead.
+     */
+    wrap?: boolean;
+    /** Whether typing characters moves the active item. Default `true`. */
+    typeahead?: boolean;
+    /** How long to wait after the last keystroke before matching. Default `200`ms. */
+    typeaheadDebounce?: number;
+    /** Whether `Home`/`End` jump to the first/last enabled item. Default `true`. */
+    homeAndEnd?: boolean;
+    /** How the active item is surfaced. Default `'roving-tabindex'`. */
+    focusMode?: AndesListFocusMode;
+    /** Text direction used to mirror horizontal arrow keys. Default `'ltr'`. */
+    textDirection?: AndesListTextDirection;
+    /** Whether disabled items are skipped while navigating. Default `true`. */
+    skipDisabled?: boolean;
+}
+/**
+ * The contract an item must satisfy to take part in list navigation.
+ *
+ * {@link AndesListNavigationItem} implements this; the interface exists so that
+ * {@link AndesListNavigation} never has to import the item directive (which imports the
+ * service), and so consumers can register their own item implementation if they need to.
+ *
+ * It is deliberately shaped to satisfy the CDK's `Highlightable` and `FocusableOption`
+ * interfaces structurally — note that `disabled` is *not* part of it: the CDK's own
+ * `ListKeyManagerOption.disabled` is a plain `boolean`, which cannot coexist with a signal
+ * input of the same name, so disabled-ness is exposed as {@link isDisabled} and wired into
+ * the key manager through its `skipPredicate` instead.
+ */
+interface AndesListNavigationItemRef {
+    /** Stable DOM `id`, used to wire `aria-activedescendant` in `active-descendant` mode. */
+    readonly itemId: string;
+    /** Whether this item should be skipped while navigating. */
+    readonly isDisabled: Signal<boolean>;
+    /** The item's host element. */
+    readonly element: HTMLElement;
+    /** Text matched against by typeahead. */
+    getLabel(): string;
+    /** Moves real DOM focus to the item. Only ever called in `roving-tabindex` mode. */
+    focus(): void;
+    /** Required by the CDK's `Highlightable`; see {@link AndesListNavigationItem}. */
+    setActiveStyles(): void;
+    /** Required by the CDK's `Highlightable`; see {@link AndesListNavigationItem}. */
+    setInactiveStyles(): void;
+}
+
+/**
+ * How many items can be selected at once.
+ *
+ * - `single` — at most one item; `value` is that item's value, or `null` when none is.
+ * - `multiple` — any number of items; `value` is an array (`null` is read as empty).
+ */
+type AndesChoiceMode = 'single' | 'multiple';
+/**
+ * The value held by a choice group: one item's value (or `null`) in `single` mode, an array
+ * of values in `multiple` mode. The two shapes share one type so `[(value)]` stays a single
+ * binding whatever the mode.
+ */
+type AndesChoiceValue<T> = T | readonly T[] | null;
+/**
+ * The `role` of the group element. It selects a whole {@link AndesChoiceRoleMapping}, so one
+ * primitive can serve every "pick from a set" pattern:
+ *
+ * - `radiogroup` — radio buttons and segmented controls.
+ * - `tablist` — tabs.
+ * - `toolbar` / `group` — toggle-button groups (`group` when it is not a toolbar).
+ * - `listbox` — a listbox whose options are the choices.
+ */
+type AndesChoiceGroupRole = 'radiogroup' | 'tablist' | 'toolbar' | 'group' | 'listbox';
+/** The `role` of each item; implied by the group's {@link AndesChoiceGroupRole}. */
+type AndesChoiceItemRole = 'radio' | 'tab' | 'button' | 'option';
+/** The ARIA attribute that carries an item's selected state under a given role. */
+type AndesChoiceStateAttribute = 'aria-checked' | 'aria-selected' | 'aria-pressed';
+/** The value of an item's `data-state` styling hook; which pair applies depends on its role. */
+type AndesChoiceDataState = 'checked' | 'unchecked' | 'active' | 'inactive' | 'on' | 'off' | 'selected' | 'unselected';
+/**
+ * Everything that differs between the patterns a choice group can render. Each
+ * {@link AndesChoiceGroupRole} has a default mapping in {@link ANDES_CHOICE_ROLE_MAPPINGS};
+ * the group's `roleMapping` input overrides single fields of it.
+ */
+interface AndesChoiceRoleMapping {
+    /** `role` set on every item. */
+    readonly itemRole: AndesChoiceItemRole;
+    /** The ARIA attribute that reports whether an item is selected. */
+    readonly stateAttribute: AndesChoiceStateAttribute;
+    /**
+     * Whether activating the selected item in `single` mode clears it. Radios and tabs never
+     * deselect; a toggle button does. (`multiple` mode always toggles.)
+     */
+    readonly toggles: boolean;
+    /**
+     * Whether keyboard navigation also selects the item it lands on, rather than waiting for
+     * `Space`/`Enter`. Only meaningful in `single` mode.
+     */
+    readonly selectionFollowsFocus: boolean;
+    /** Whether the role supports `aria-required`, which `required` is then published as. */
+    readonly ariaRequired: boolean;
+    /** Which arrow keys navigate when `orientation` is not set explicitly. */
+    readonly orientation: 'horizontal' | 'vertical' | 'both';
+}
+/**
+ * Default {@link AndesChoiceRoleMapping} for every {@link AndesChoiceGroupRole}, following
+ * the WAI-ARIA Authoring Practices pattern of the same name.
+ */
+declare const ANDES_CHOICE_ROLE_MAPPINGS: Readonly<Record<AndesChoiceGroupRole, AndesChoiceRoleMapping>>;
+/**
+ * What the group needs to know about one of its items. {@link AndesChoiceItem} implements
+ * it; the group only ever sees items through this contract, which is what lets the two
+ * classes live in separate files without importing each other.
+ */
+interface AndesChoiceItemRef extends AndesListNavigationItemRef {
+    /** The value this item stands for, compared against the group's value. */
+    readonly value: Signal<unknown>;
+}
+
+/**
+ * The shared behavior of every "choose from a set" control: one tab stop, arrow keys move
+ * between items, and `Space`/`Enter` (or focus itself) select. It owns the selection and
+ * the roving focus, and publishes the ARIA that goes with them; the consuming component
+ * owns the markup and the styling.
+ *
+ * The same directive serves radio groups, segmented controls, tabs, toggle-button groups
+ * and listbox-style pickers. What changes between them is only data — the group's
+ * {@link role} picks a default {@link AndesChoiceRoleMapping} (item role, which `aria-*`
+ * attribute carries the selected state, whether focus selects, which arrows navigate).
+ *
+ * Roving focus is {@link AndesListNavigation}'s: the group provides its own instance, so
+ * items — including ones rendered by a descendant component — find it through DI, and
+ * arrow-key movement, `Home`/`End`, wrap-around and disabled-item skipping are the shared
+ * implementation rather than a per-component copy.
+ *
+ * ```html
+ * <div andesChoiceGroup role="radiogroup" [(value)]="size" aria-label="Size">
+ *   @for (option of options; track option.value) {
+ *     <button type="button" andesChoiceItem [value]="option.value" [disabled]="option.disabled">
+ *       {{ option.label }}
+ *     </button>
+ *   }
+ * </div>
+ * ```
+ *
+ * `value` follows the user and the program alike: setting it (or binding `[value]`)
+ * updates every item, but only the user's own selection fires {@link changed} — the
+ * convention form-control wrappers need to tell the two apart.
+ */
+declare class AndesChoiceGroup<T = unknown> {
+    private readonly navigation;
+    private readonly directionality;
+    private readonly host;
+    /**
+     * The selected value: one item's value (or `null`) in `single` mode, an array in
+     * `multiple` mode. Two-way bindable.
+     */
+    readonly value: _angular_core.ModelSignal<AndesChoiceValue<T>>;
+    /** Whether one or many items can be selected. Default `'single'`. */
+    readonly mode: _angular_core.InputSignal<AndesChoiceMode>;
+    /**
+     * The ARIA role of the group, which also decides the role and selected-state attribute
+     * of its items (see {@link AndesChoiceRoleMapping}). Default `'radiogroup'`.
+     */
+    readonly role: _angular_core.InputSignal<AndesChoiceGroupRole>;
+    /**
+     * Overrides individual fields of the mapping {@link role} selects, for the rare pattern
+     * that sits between two of them — e.g. a `toolbar` of items that do not deselect.
+     */
+    readonly roleMapping: _angular_core.InputSignal<Partial<AndesChoiceRoleMapping> | undefined>;
+    /**
+     * Whether `single` mode must always keep a selection: activating the selected item then
+     * does nothing instead of clearing it. Also published as `aria-required` on roles that
+     * support it. Has no effect on `multiple` mode.
+     */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether activating the selected item clears it in `single` mode. Defaults to what the
+     * {@link role} does natively — a toggle button deselects, a radio or tab does not.
+     */
+    readonly deselectable: _angular_core.InputSignal<boolean | undefined>;
+    /** Disables every item: none can be focused, navigated to or selected. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether keyboard navigation selects the item it lands on (radio buttons, automatic
+     * tabs) or only moves focus until `Space`/`Enter` (manual tabs, toggle groups). Defaults
+     * to what the {@link role} does natively. Ignored in `multiple` mode, where moving
+     * through the items must not change a selection.
+     */
+    readonly selectionFollowsFocus: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * Which arrow keys navigate: `horizontal` (mirrored for right-to-left), `vertical`, or
+     * `both`. Defaults to what the {@link role} does natively.
+     */
+    readonly orientation: _angular_core.InputSignal<AndesListOrientation | undefined>;
+    /** Whether navigation wraps from the last item to the first, and back. Default `true`. */
+    readonly wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether typing a character moves focus to the matching item. Off by default: only a
+     * listbox-style picker usually wants it, and it would otherwise compete with `Space`.
+     */
+    readonly typeahead: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Overrides the text direction otherwise read from the surrounding `dir`, so a right-to-left
+     * group can be forced inside a left-to-right page (and vice versa).
+     */
+    readonly textDirection: _angular_core.InputSignal<AndesListTextDirection | undefined>;
+    /**
+     * Decides whether two values are the same choice. Defaults to `Object.is`; supply one
+     * when items stand for objects that are re-created between renders.
+     */
+    readonly compareWith: _angular_core.InputSignal<(a: T, b: T) => boolean>;
+    /**
+     * Fires with the new value when the *user* changes the selection — by clicking, by
+     * `Space`/`Enter`, or by navigating when selection follows focus. It does not fire for
+     * writes to {@link value}. (Named `changed` so it cannot be mistaken for the native
+     * `change` event that bubbles out of form controls placed inside.)
+     */
+    readonly changed: _angular_core.OutputEmitterRef<AndesChoiceValue<T>>;
+    private readonly forcedDisabled;
+    /**
+     * Whether the group is disabled, by its input or through {@link setDisabledState}.
+     * Items read this to disable themselves.
+     */
+    readonly isDisabled: Signal<boolean>;
+    /** The role mapping in effect: the {@link role}'s default with any overrides applied. */
+    readonly mapping: Signal<AndesChoiceRoleMapping>;
+    /** The orientation in effect, after falling back to the role's default. */
+    protected readonly resolvedOrientation: Signal<AndesListOrientation>;
+    /** The text direction in effect: the {@link textDirection} input, else the surrounding `dir`. */
+    readonly direction: Signal<AndesListTextDirection>;
+    /** Whether activating the selected item clears it. `multiple` mode always toggles. */
+    readonly toggles: Signal<boolean>;
+    /** Whether navigating selects. Only ever true in `single` mode. */
+    readonly followsFocus: Signal<boolean>;
+    /** The selected values as an array, whatever the mode. */
+    readonly values: Signal<readonly T[]>;
+    /**
+     * Every choice item registered with the group, in DOM order. Items register themselves,
+     * so `@if`/`@for`-rendered items need no bookkeeping.
+     */
+    readonly items: Signal<readonly AndesChoiceItemRef[]>;
+    /** The first selected item that can be focused: the one that carries the tab stop. */
+    readonly selectedItem: Signal<AndesChoiceItemRef | null>;
+    protected readonly ariaOrientation: Signal<"vertical" | "horizontal" | null>;
+    protected readonly ariaMultiselectable: Signal<"true" | null>;
+    protected readonly ariaRequired: Signal<"true" | null>;
+    constructor();
+    /** Whether `value` is part of the current selection. */
+    isSelected(value: T): boolean;
+    /**
+     * Selects `value` as the user would: in `multiple` mode it is added, in `single` mode it
+     * replaces the selection. Disabled groups and unknown values are ignored. Fires
+     * {@link changed} when the selection actually changes.
+     */
+    select(value: T): void;
+    /**
+     * Deselects `value` as the user would. In `single` mode this is refused when the group is
+     * {@link required}. Fires {@link changed} when the selection actually changes.
+     */
+    deselect(value: T): void;
+    /** Selects `value` if it is not selected, otherwise deselects it. */
+    toggle(value: T): void;
+    /**
+     * Empties the selection as the user would. Refused in `single` mode when the group is
+     * {@link required}. Fires {@link changed} when the selection actually changes.
+     */
+    clear(): void;
+    /**
+     * Moves focus into the group: onto the selected item, or the first one that can take
+     * focus — the same item a Tab press lands on.
+     */
+    focus(options?: FocusOptions): void;
+    /**
+     * Disables the group from outside the template, for wrappers that implement
+     * `ControlValueAccessor.setDisabledState`. Combined with the `disabled` input, so
+     * either one disables the group.
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * The user activated an item (click, `Space` or `Enter`). Called by
+     * {@link AndesChoiceItem}; follows the toggle rules of the current mapping.
+     * @internal
+     */
+    activate(item: AndesChoiceItemRef): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onKeyup(event: KeyboardEvent): void;
+    protected onFocusout(event: FocusEvent): void;
+    private isTypingSpace;
+    private itemFor;
+    private moveTabStopTo;
+    private commit;
+    private syncNavigation;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesChoiceGroup<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AndesChoiceGroup<any>, "[andesChoiceGroup]", ["andesChoiceGroup"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "roleMapping": { "alias": "roleMapping"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "deselectable": { "alias": "deselectable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selectionFollowsFocus": { "alias": "selectionFollowsFocus"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "typeahead": { "alias": "typeahead"; "required": false; "isSignal": true; }; "textDirection": { "alias": "textDirection"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; }, never, never, true, never>;
+}
+
+/**
+ * One choice inside an {@link AndesChoiceGroup}: a radio, a tab, a toggle button or an
+ * option. Registers itself with the group on init and removes itself on destroy.
+ *
+ * It publishes the roving `tabindex`, the item `role`, the selected-state attribute the
+ * group's role mapping calls for (`aria-checked`, `aria-selected` or `aria-pressed`), and
+ * `data-state`/`data-disabled`/`data-active` hooks for styling. It sets no CSS.
+ *
+ * ```html
+ * <button type="button" andesChoiceItem value="list" [controls]="'panel-list'">List</button>
+ * ```
+ *
+ * Put it on the element that takes keyboard focus. A `<button>` is the usual choice — it
+ * gets native `disabled` for free — but any element works, since `Space` and `Enter` are
+ * handled by the group instead of relying on a native click.
+ */
+declare class AndesChoiceItem<T = unknown> implements AndesChoiceItemRef, OnInit, OnDestroy {
+    private readonly group;
+    private readonly navigation;
+    /** The value this item stands for. Compared with the group's value (see its `compareWith`). */
+    readonly value: _angular_core.InputSignal<T>;
+    /** Disables this item: it is skipped by navigation and cannot be selected. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The `id` of the element this item controls — the tab panel, for a tab. Published as
+     * `aria-controls`; leaving it unset omits the attribute, which is right for patterns
+     * that control nothing.
+     */
+    readonly controls: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Text that typeahead matches against. Defaults to the item's own text content; set it
+     * when the visible text is an icon or is split across elements.
+     */
+    readonly typeaheadLabel: _angular_core.InputSignal<string | undefined>;
+    readonly element: HTMLElement;
+    /** The item's DOM `id` — its own, when it has one, so authored ids are never replaced. */
+    readonly itemId: string;
+    /** Only a native button has a `disabled` attribute worth setting; other elements get ARIA only. */
+    protected readonly nativeDisabled: boolean;
+    /** Whether the item is disabled, on its own or because its group is. */
+    readonly isDisabled: Signal<boolean>;
+    /** Whether this item is part of the group's selection. */
+    readonly selected: Signal<boolean>;
+    /** Whether this item holds the group's roving focus (the one tab stop). */
+    readonly active: Signal<boolean>;
+    protected readonly role: Signal<_andes_ng_primitives.AndesChoiceItemRole>;
+    protected readonly stateAttribute: Signal<AndesChoiceStateAttribute>;
+    /** Styling hook whose vocabulary matches the role: checked, active (tab), on, or selected. */
+    protected readonly dataState: Signal<AndesChoiceDataState>;
+    /** `0` on the one roving tab stop, `-1` on the rest (and on everything while disabled). */
+    protected readonly tabIndex: Signal<0 | -1>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getLabel(): string;
+    focus(): void;
+    setActiveStyles(): void;
+    setInactiveStyles(): void;
+    protected onClick(): void;
+    /** Keeps the tab stop on whichever item the user reached, however they reached it. */
+    protected onFocusin(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesChoiceItem<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AndesChoiceItem<any>, "[andesChoiceItem]", ["andesChoiceItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "controls": { "alias": "controls"; "required": false; "isSignal": true; }; "typeaheadLabel": { "alias": "typeaheadLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Identifies a node. Keys are compared with `===`, so `1` and `'1'` are different nodes. */
+type AndesTreeNavigationKey = string | number;
+/**
+ * Which arrow keys move between nodes.
+ *
+ * - `vertical` — `ArrowUp`/`ArrowDown` move, `ArrowRight`/`ArrowLeft` (mirrored for RTL) open
+ *   and close. The WAI-ARIA TreeView layout; also nested menus and cascading columns.
+ * - `horizontal` — `ArrowLeft`/`ArrowRight` (mirrored for RTL) move, `ArrowDown` opens and
+ *   `ArrowUp` closes. The menubar layout, where the top level runs sideways and submenus drop
+ *   down.
+ *
+ * The orientation is a property of the whole navigation. A bar whose panels run in the other
+ * direction uses one navigation for the bar and one per panel, because each panel is its own
+ * keyboard scope anyway.
+ */
+type AndesTreeOrientation = 'vertical' | 'horizontal';
+/**
+ * Which nodes a move key walks over.
+ *
+ * - `tree` — every visible node, depth first, regardless of level. `Up`/`Down` step across
+ *   level boundaries and `Home`/`End` reach the first/last visible node. The TreeView default.
+ * - `level` — only the siblings of the active node. `Up`/`Down`, `Home`/`End` and typeahead
+ *   stay inside the current group, and only the open/close keys change level. This is how a
+ *   cascading column picker or a menu with fly-out submenus behaves: each group is its own
+ *   list.
+ */
+type AndesTreeNavigationScope = 'tree' | 'level';
+/**
+ * How the active node is surfaced to assistive technology.
+ *
+ * - `roving-tabindex` — nodes are genuinely focusable and real DOM focus moves between them;
+ *   exactly one node carries `tabindex="0"` and the rest `tabindex="-1"`. Use this when the
+ *   tree itself holds focus.
+ * - `active-descendant` — real DOM focus stays on one element (a search input, a popup
+ *   container) and the active node is communicated through `aria-activedescendant`. Nodes get
+ *   no `tabindex`.
+ */
+type AndesTreeFocusMode = 'roving-tabindex' | 'active-descendant';
+/** Text direction used to mirror the horizontal arrow keys. */
+type AndesTreeTextDirection = 'ltr' | 'rtl';
+/**
+ * A node as the navigation needs to know it. This is what an {@link AndesTreeNavigationNodeSource}
+ * returns, and what items contribute when no source is set.
+ */
+interface AndesTreeNavigationNode {
+    /** Unique key of the node. */
+    readonly key: AndesTreeNavigationKey;
+    /**
+     * Key of the parent node. `null`, `undefined` and a key that names no known node all make
+     * the node a root, so a partially loaded tree degrades to "shown at the top" rather than
+     * disappearing.
+     */
+    readonly parentKey?: AndesTreeNavigationKey | null;
+    /** Whether keyboard navigation skips the node (see {@link AndesTreeNavigationConfig.skipDisabled}). */
+    readonly disabled?: boolean;
+    /**
+     * Whether the node can be expanded. Leave it out to derive it from "has known children";
+     * set it to `true` for a parent whose children are not loaded or not rendered yet, which is
+     * what lets `ArrowRight` open it and trigger the load.
+     */
+    readonly expandable?: boolean;
+    /** Text typeahead matches against. Defaults to the mounted item's own text, else `''`. */
+    readonly label?: string;
+}
+/**
+ * Supplies the nodes of the tree in **data order**: siblings in the order they appear, parents
+ * identified by `parentKey`. Parents do not have to precede their children, and the nodes do
+ * not have to be mounted.
+ *
+ * This is what makes windowed (virtualized) trees work: rows that are scrolled out of view have
+ * no item, but they are still part of the keyboard order. Read signals inside it freely — it is
+ * called from a `computed`, so the navigation follows whatever it reads.
+ */
+type AndesTreeNavigationNodeSource = () => readonly AndesTreeNavigationNode[];
+/**
+ * A node as the navigation resolved it: the hierarchy facts a tree row needs for its ARIA
+ * attributes, independent of whether the node is expanded.
+ */
+interface AndesTreeNavigationNodeInfo {
+    /** The node's key. */
+    readonly key: AndesTreeNavigationKey;
+    /** Key of the parent, or `null` for a root. */
+    readonly parentKey: AndesTreeNavigationKey | null;
+    /** 1 for a root; becomes `aria-level`. */
+    readonly level: number;
+    /**
+     * 1-based position among all siblings; becomes `aria-posinset`. Collapsed and hidden
+     * siblings count, as the WAI-ARIA pattern asks.
+     */
+    readonly posInSet: number;
+    /** Number of siblings, the node included; becomes `aria-setsize`. */
+    readonly setSize: number;
+    /** Whether keyboard navigation skips the node. */
+    readonly disabled: boolean;
+    /** Whether the node can be expanded: declared explicitly, or because it has known children. */
+    readonly expandable: boolean;
+}
+/** Reported when navigation expands or collapses a node. */
+interface AndesTreeNavigationExpandChange {
+    /** The node that changed. */
+    readonly key: AndesTreeNavigationKey;
+    /** Its new state. */
+    readonly expanded: boolean;
+}
+/**
+ * Reported when keyboard navigation lands on a node that has no mounted item, i.e. a row
+ * outside a virtual list's rendered window. The consumer scrolls to {@link index}; when the
+ * row's item mounts it takes focus (or scrolls itself into view) on its own.
+ */
+interface AndesTreeNavigationRevealRequest {
+    /** The node navigation moved to. */
+    readonly key: AndesTreeNavigationKey;
+    /** Its index among the visible nodes. */
+    readonly index: number;
+}
+/**
+ * A writable signal the navigation can keep the expanded keys in, so the owner of the state
+ * stays the consumer. A `Set` and a plain array are both accepted — whichever shape the signal
+ * currently holds is the shape that gets written back.
+ */
+type AndesTreeNavigationExpandedSource<K extends AndesTreeNavigationKey = AndesTreeNavigationKey> = WritableSignal<ReadonlySet<K>> | WritableSignal<readonly K[]>;
+/**
+ * Options accepted by {@link AndesTreeNavigation.configure}. Every key is optional; an omitted
+ * key leaves the current value untouched, so `configure` is safe to call from an `effect` that
+ * only knows about some of the options.
+ */
+interface AndesTreeNavigationConfig {
+    /** Which arrow keys move and which open/close. Default `'vertical'`. */
+    orientation?: AndesTreeOrientation;
+    /** Which nodes a move walks over. Default `'tree'`. */
+    scope?: AndesTreeNavigationScope;
+    /**
+     * Whether moving past the first/last node wraps around. Default `false`, as in the
+     * TreeView pattern. Menus and accordions turn it on.
+     */
+    wrap?: boolean;
+    /** Whether typing characters moves to the next node whose label matches. Default `true`. */
+    typeahead?: boolean;
+    /** How long a typeahead query stays buffered after the last keystroke. Default `500`ms. */
+    typeaheadDebounce?: number;
+    /** Whether `Home`/`End` jump to the first/last node. Default `true`. */
+    homeAndEnd?: boolean;
+    /** Whether `*` expands every sibling of the active node. Default `true`. */
+    expandSiblings?: boolean;
+    /** How the active node is surfaced. Default `'roving-tabindex'`. */
+    focusMode?: AndesTreeFocusMode;
+    /** Text direction used to mirror the horizontal arrow keys. Default `'ltr'`. */
+    textDirection?: AndesTreeTextDirection;
+    /** Whether disabled nodes are skipped while navigating. Default `true`. */
+    skipDisabled?: boolean;
+    /**
+     * Whether the keyboard may expand and collapse a disabled node. Only matters when
+     * {@link skipDisabled} is `false` and disabled nodes can therefore hold focus. Default
+     * `false`: a disabled node is inert. Trees whose "disabled" nodes are only unselectable, not
+     * unopenable, turn this on.
+     */
+    expandDisabled?: boolean;
+    /**
+     * Whether the open key, pressed on a collapsed parent, also moves into its first child
+     * instead of only opening it. Default `false` (the TreeView pattern: open, stay). Menus and
+     * cascading columns turn it on. If the children are not there yet the move happens as soon
+     * as they appear.
+     */
+    enterOnExpand?: boolean;
+    /**
+     * Whether the close key, pressed on a child, also collapses the parent it steps back to.
+     * Default `false` (the TreeView pattern: just move). Menus turn it on, because leaving a
+     * submenu closes it.
+     */
+    collapseOnLeave?: boolean;
+    /**
+     * Initial or replacement expanded keys. Applies to whichever store is current: the
+     * navigation's own, or the one passed to {@link AndesTreeNavigation.bindExpanded}.
+     */
+    expanded?: Iterable<AndesTreeNavigationKey>;
+}
+/**
+ * The contract an item must satisfy to take part in tree navigation.
+ *
+ * {@link AndesTreeNavigationItem} implements this; the interface exists so that
+ * {@link AndesTreeNavigation} never has to import the item directive (which imports the
+ * service), and so consumers can register their own item implementation if they need to.
+ */
+interface AndesTreeNavigationItemRef {
+    /** Stable DOM `id`, used to wire `aria-activedescendant` in `active-descendant` mode. */
+    readonly itemId: string;
+    /** The item's host element. */
+    readonly element: HTMLElement;
+    /** The node's key. */
+    readonly itemKey: Signal<AndesTreeNavigationKey>;
+    /** The parent's key, `null` for a root. */
+    readonly itemParentKey: Signal<AndesTreeNavigationKey | null>;
+    /** Whether navigation should skip the item. */
+    readonly isDisabled: Signal<boolean>;
+    /** Explicit expandability; `undefined` means "derive it from the children". */
+    readonly isExpandable: Signal<boolean | undefined>;
+    /** Text matched against by typeahead. */
+    getLabel(): string;
+    /** Moves real DOM focus to the item. Only called in `roving-tabindex` mode. */
+    focus(): void;
+    /** Brings the item into view without moving focus. Only called in `active-descendant` mode. */
+    reveal(): void;
+}
+
+/** Default time a typeahead query stays buffered, matching the WAI-ARIA examples. */
+declare const ANDES_TREE_TYPEAHEAD_DEBOUNCE = 500;
+/**
+ * Shared keyboard-navigation state for hierarchical widgets: trees, cascading pickers, menus
+ * with fly-out submenus, grouped navigation. It owns the *visible-node* order (collapsed
+ * subtrees are skipped), the active node, the expanded keys, the WAI-ARIA TreeView keys and
+ * the ARIA facts (`aria-level`, `aria-posinset`, `aria-setsize`, `aria-expanded`) a node needs.
+ *
+ * It is a DI-scoped service, not a directive: provide it from the consuming component so that
+ * every descendant item — including items rendered into a CDK overlay, which are injector
+ * descendants but not DOM descendants — can inject the same instance.
+ *
+ * ```ts
+ * @Component({
+ *   selector: 'andes-tree',
+ *   providers: [AndesTreeNavigation],
+ *   template: `
+ *     <ul role="tree" andesTreeNavigationKeys>
+ *       @for (node of nodes(); track node.key) {
+ *         <li
+ *           role="treeitem"
+ *           [andesTreeNavigationItem]="node.key"
+ *           [parentKey]="node.parentKey"
+ *           [disabled]="node.disabled"
+ *         >
+ *           {{ node.title }}
+ *         </li>
+ *       }
+ *     </ul>
+ *   `,
+ * })
+ * export class AndesTree {
+ *   protected readonly navigation = inject(AndesTreeNavigation);
+ * }
+ * ```
+ *
+ * ### Where the structure comes from
+ *
+ * By default the structure is read from the registered items: each item names its key and its
+ * parent, and their DOM order is the sibling order. That is exact for any tree that renders all
+ * of its nodes. A **windowed** tree renders only the rows in view, so items come and go as the
+ * user scrolls; for those, give the navigation the nodes directly with {@link setNodes}. Its
+ * data order then drives everything, and rows that are not mounted are still part of the
+ * keyboard order: moving onto one emits {@link revealRequested} so the list can scroll to it,
+ * and the item takes focus the moment it mounts.
+ *
+ * ### What it deliberately does not do
+ *
+ * It owns no selection or checked state, sets no `role`, and never interprets `Enter` or
+ * `Space` — activation is the consumer's. "Active node" is keyboard focus, not selection.
+ */
+declare class AndesTreeNavigation {
+    private readonly destroyRef;
+    private readonly document;
+    private readonly isBrowser;
+    /** Which arrow keys move and which open/close. */
+    readonly orientation: WritableSignal<AndesTreeOrientation>;
+    /** Which nodes a move key walks over. */
+    readonly scope: WritableSignal<AndesTreeNavigationScope>;
+    /** Whether moving past the first/last node wraps around. */
+    readonly wrap: WritableSignal<boolean>;
+    /** Whether typing characters moves to the next matching node. */
+    readonly typeahead: WritableSignal<boolean>;
+    /** How long a typeahead query stays buffered after the last keystroke. */
+    readonly typeaheadDebounce: WritableSignal<number>;
+    /** Whether `Home`/`End` jump to the first/last node. */
+    readonly homeAndEnd: WritableSignal<boolean>;
+    /** Whether `*` expands every sibling of the active node. */
+    readonly expandSiblings: WritableSignal<boolean>;
+    /** How the active node is surfaced to assistive technology. */
+    readonly focusMode: WritableSignal<AndesTreeFocusMode>;
+    /** Text direction used to mirror the horizontal arrow keys. */
+    readonly textDirection: WritableSignal<AndesTreeTextDirection>;
+    /** Whether disabled nodes are skipped while navigating. */
+    readonly skipDisabled: WritableSignal<boolean>;
+    /** Whether the keyboard may expand and collapse a disabled node. */
+    readonly expandDisabled: WritableSignal<boolean>;
+    /** Whether the open key on a collapsed parent also steps into its first child. */
+    readonly enterOnExpand: WritableSignal<boolean>;
+    /** Whether the close key on a child also collapses the parent it steps back to. */
+    readonly collapseOnLeave: WritableSignal<boolean>;
+    private readonly source;
+    private readonly registered;
+    private readonly orderVersion;
+    /**
+     * Every registered item, in DOM order. Items that scroll out of a windowed tree are not in
+     * here, which is why the navigation reads its structure from {@link setNodes} there.
+     */
+    readonly items: Signal<readonly AndesTreeNavigationItemRef[]>;
+    private readonly itemByKey;
+    private readonly itemByElement;
+    private readonly nodes;
+    private readonly structure;
+    private readonly ownExpanded;
+    private readonly expandedStore;
+    /** The keys of the expanded nodes. */
+    readonly expandedKeys: Signal<ReadonlySet<AndesTreeNavigationKey>>;
+    private readonly visible;
+    /**
+     * The nodes a user can reach, in reading order: every node whose ancestors are all expanded.
+     * This — not the DOM — is the order the arrow keys follow, so collapsed subtrees cost
+     * nothing and an unmounted row still has its place. A virtual list renders a window of it.
+     */
+    readonly visibleNodes: Signal<readonly AndesTreeNavigationNodeInfo[]>;
+    private readonly visibleIndex;
+    private readonly _activeKey;
+    /** The active node's key, or `null` when nothing is active yet. */
+    readonly activeKey: Signal<AndesTreeNavigationKey | null>;
+    /** The active node's mounted item, or `null` — also when the node is outside a window. */
+    readonly activeItem: Signal<AndesTreeNavigationItemRef | null>;
+    /** Index of the active node within {@link visibleNodes}, or `-1`. */
+    readonly activeIndex: Signal<number>;
+    /**
+     * The `id` to publish as `aria-activedescendant`, or `null` in `roving-tabindex` mode (where
+     * real focus already conveys the active node) and while the active node has no mounted item.
+     */
+    readonly activeDescendantId: Signal<string | null>;
+    /**
+     * The node that should carry `tabindex="0"` in `roving-tabindex` mode: the active node, or —
+     * before anything is active, or once the active node is hidden or skipped — the first node
+     * the user can navigate to, so the tree is always reachable with one Tab press.
+     */
+    readonly tabbableKey: Signal<AndesTreeNavigationKey | null>;
+    /**
+     * `0` when the tree has a tab stop but no mounted item to put it on — the tabbable node is
+     * outside a windowed tree's rendered range — and `null` otherwise. Bind it to the
+     * container's `tabindex` in virtualized templates; {@link AndesTreeNavigationKeys} forwards
+     * focus on the container to the tabbable node, which scrolls it in.
+     */
+    readonly containerTabIndex: Signal<0 | null>;
+    private readonly _expandedChange;
+    /**
+     * Emits whenever the navigation expands or collapses a node on the user's behalf — an arrow
+     * key, `*`, or {@link expand}/{@link collapse}/{@link toggle}. This is where a lazy tree
+     * starts loading children. {@link setExpanded} and `configure({ expanded })` are the consumer
+     * speaking, so they do not echo back.
+     */
+    readonly expandedChange: Observable<AndesTreeNavigationExpandChange>;
+    private readonly _revealRequested;
+    /**
+     * Emits when navigation lands on a node that has no mounted item (see {@link setNodes}).
+     * Scroll the list to the given index; the item focuses itself when it mounts.
+     */
+    readonly revealRequested: Observable<AndesTreeNavigationRevealRequest>;
+    private readonly _tabOut;
+    /** Emits when `Tab` is pressed, so a menu or popup can close and hand focus back. */
+    readonly tabOut: Observable<void>;
+    private typeaheadBuffer;
+    private typeaheadTimer;
+    /** The node focus should land on as soon as its item mounts. */
+    private pendingFocusKey;
+    /** The parent to step into as soon as it has a child (`enterOnExpand` with lazy children). */
+    private pendingEnterKey;
+    /** The active node's ancestors, nearest first, kept for when the node itself disappears. */
+    private activeAncestry;
+    /** Whether keyboard focus was last seen on one of this navigation's items. */
+    private focusInside;
+    private destroyed;
+    constructor();
+    /** Applies any subset of the configuration options in one call. */
+    configure(config: AndesTreeNavigationConfig): void;
+    /**
+     * Supplies the nodes in data order instead of reading them from the registered items — the
+     * mode for windowed trees, and for any tree that wants to navigate nodes it has not rendered.
+     * Pass `null` to go back to deriving the structure from items.
+     *
+     * The function runs inside a `computed`, so signals it reads (the node list, a loaded-children
+     * map) keep the navigation up to date by themselves.
+     */
+    setNodes(source: AndesTreeNavigationNodeSource | null): void;
+    /**
+     * Keeps the expanded keys in a signal the consumer owns, e.g. a component's `model()`, so
+     * the state has one home and two-way binding just works. A `Set` and an array are both
+     * accepted; whichever shape the signal holds is written back. Pass `null` to return to the
+     * navigation's own store.
+     */
+    bindExpanded<K extends AndesTreeNavigationKey>(source: AndesTreeNavigationExpandedSource<K> | null): void;
+    /** Adds an item to the tree. Called by `AndesTreeNavigationItem` on init. */
+    register(item: AndesTreeNavigationItemRef): void;
+    /**
+     * Removes an item from the tree. Called by `AndesTreeNavigationItem` on destroy. If that item
+     * was the active one, the reconcile that follows decides where the active node goes.
+     */
+    unregister(item: AndesTreeNavigationItemRef): void;
+    /**
+     * Re-reads the DOM order of the items. The order is re-checked whenever the tree's structure
+     * changes, but moving existing elements around (re-sorting a `@for` list) changes no signal,
+     * so call this after such a reorder. Trees fed by {@link setNodes} never need it.
+     */
+    refreshOrder(): void;
+    /** The hierarchy facts of a node, or `null` for a key the navigation does not know. */
+    nodeInfo(key: AndesTreeNavigationKey): AndesTreeNavigationNodeInfo | null;
+    /** Index of a node among the {@link visibleNodes}, or `-1` when it is hidden or unknown. */
+    visibleIndexOf(key: AndesTreeNavigationKey): number;
+    /** The mounted item of a node, if it has one. */
+    itemForKey(key: AndesTreeNavigationKey): AndesTreeNavigationItemRef | null;
+    /** Whether a node is expanded. */
+    isExpanded(key: AndesTreeNavigationKey): boolean;
+    /** Expands a node that can be expanded. Returns whether anything changed. */
+    expand(key: AndesTreeNavigationKey): boolean;
+    /** Collapses a node. If the active node was inside it, the active node becomes this one. */
+    collapse(key: AndesTreeNavigationKey): boolean;
+    /** Expands a collapsed node and collapses an expanded one. */
+    toggle(key: AndesTreeNavigationKey): boolean;
+    /** Expands every known node that can be expanded. */
+    expandAll(): void;
+    /** Collapses every node. */
+    collapseAll(): void;
+    /** Expands every ancestor of a node, so that the node becomes visible. */
+    expandTo(key: AndesTreeNavigationKey): void;
+    /**
+     * Replaces the expanded keys. This is the consumer setting state, so it emits no
+     * {@link expandedChange}.
+     */
+    setExpanded(keys: Iterable<AndesTreeNavigationKey>): void;
+    /**
+     * Makes a visible, navigable node active and brings it into focus. In `roving-tabindex` mode
+     * that moves real focus to its item; in `active-descendant` mode it scrolls the item into
+     * view. If the node has no mounted item (a windowed tree) it is still made active, and
+     * {@link revealRequested} asks the list to render it. Returns `false` for a hidden, unknown
+     * or skipped node, leaving everything as it was.
+     */
+    focusKey(key: AndesTreeNavigationKey): boolean;
+    /** Moves the active node to the first navigable node of the current scope. */
+    focusFirst(): void;
+    /** Moves the active node to the last navigable node of the current scope. */
+    focusLast(): void;
+    /** Moves the active node to the next navigable node, respecting {@link wrap}. */
+    focusNext(): void;
+    /** Moves the active node to the previous navigable node, respecting {@link wrap}. */
+    focusPrevious(): void;
+    /**
+     * Moves the active pointer without focusing anything — for restoring the active node on
+     * init (say, the selected one), or following a click that already moved real focus. Accepts
+     * any known node, even one that is currently collapsed away. Returns `false` for an unknown
+     * key.
+     */
+    setActiveKeySilently(key: AndesTreeNavigationKey | null): boolean;
+    /** Clears the active node, e.g. when a popup closes. */
+    clearActive(): void;
+    /** Whether a typeahead query is currently buffered. */
+    isTyping(): boolean;
+    /** Discards any buffered typeahead query. */
+    cancelTypeahead(): void;
+    private clearTypeaheadTimer;
+    /**
+     * Called by an item when real focus lands on it, so the active node follows the mouse or a
+     * direct Tab and Tabbing away and back returns to the same place.
+     */
+    onItemFocusin(item: AndesTreeNavigationItemRef): void;
+    /**
+     * Called by an item when it loses focus. Focus that merely moves to another node keeps the
+     * "focus is in the tree" memory; so does an item that was removed while focused, which is
+     * exactly the case where focus must be handed to an ancestor instead of being lost.
+     */
+    onItemFocusout(item: AndesTreeNavigationItemRef, event: FocusEvent): void;
+    /**
+     * Called by an item once it has rendered, so a node that navigation reached before it was
+     * mounted (a windowed tree) receives the focus it was promised.
+     */
+    onItemRendered(item: AndesTreeNavigationItemRef): void;
+    /**
+     * Handles a `keydown` on whichever element owns keyboard focus for this tree — the tree or a
+     * node in `roving-tabindex` mode, the input in `active-descendant` mode.
+     * `AndesTreeNavigationKeys` wires this up for you.
+     *
+     * Only navigation keys are consumed (and `preventDefault`ed): the four arrows, `Home`, `End`,
+     * `*` and typeahead characters. `Enter`, `Space` (outside a typeahead query) and `Escape`
+     * are left entirely to the consumer, as are keys typed into a control nested inside a node
+     * and any event a consumer handler already `preventDefault`ed — which is how a multi-select
+     * tree claims `Shift`+arrow before the navigation sees it.
+     */
+    onKeydown(event: KeyboardEvent): void;
+    private handleKey;
+    /** Maps an arrow key to what it means in the current orientation and direction. */
+    private commandFor;
+    /**
+     * Where a key press came from: the key of the node whose item it was typed on, `null` for
+     * the container itself, or `'inside-node'` for a control nested inside a node, whose keys
+     * belong to that control.
+     */
+    private keyOrigin;
+    /** The active node's record, provided it is still visible. */
+    private currentRecord;
+    private isSkipped;
+    private isNavigable;
+    private canToggle;
+    /** The nodes a move key walks over: everything visible, or just the active node's group. */
+    private scopeList;
+    private indexInScope;
+    private move;
+    private stepFrom;
+    private edgeOf;
+    private focusEdge;
+    private firstNavigableChild;
+    /** Opens a collapsed parent, or steps into the first child of an open one. */
+    private open;
+    private stepIntoOrWait;
+    /** Closes an open parent, or steps out to the nearest navigable ancestor. */
+    private close;
+    private expandSiblingsOf;
+    private matchTypeahead;
+    private findByPrefix;
+    private labelOf;
+    /** Records the active node and its ancestry, and drops waits that belonged to the old one. */
+    private activate;
+    private applyFocus;
+    private currentStore;
+    /**
+     * Writes a new expanded set, optionally announcing what changed, and then makes sure the
+     * active node is still somewhere a user can be.
+     */
+    private commitExpanded;
+    /**
+     * Keeps the active node somewhere reachable. When it has been hidden by a collapse, it moves
+     * to the nearest visible ancestor — and takes real focus along if the tree had it. When it
+     * has been deleted from a node source, the same applies to its remembered ancestry. When an
+     * item-derived node merely disappears, nothing is guessed and the active node is cleared:
+     * an unmounted item is not evidence that the node is gone.
+     */
+    private reconcileActive;
+    /** Whether keyboard focus is on this tree right now, or was when its node was removed. */
+    private hadFocus;
+    /** Finishes a step into a parent whose children were not there when the key was pressed. */
+    private resolvePendingEnter;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesTreeNavigation, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AndesTreeNavigation>;
+}
+
+/**
+ * One node of a tree governed by {@link AndesTreeNavigation}: a tree item, a menu item with a
+ * submenu, a cascader option. It tells the navigation who it is (`key`), where it sits
+ * (`parentKey`, or the enclosing item when items are nested in the template), whether it is
+ * `disabled` or `expandable`, and in return receives everything a node needs as signals:
+ * `ariaLevel`, `ariaPosinset`, `ariaSetsize`, `ariaExpanded`, `tabIndex`, `active`.
+ *
+ * It registers on init and unregisters on destroy, so `@if`/`@for`-driven trees and
+ * windowed lists, whose items come and go as the user scrolls, need no bookkeeping.
+ *
+ * By default it also writes those facts to the host (`id`, `tabindex`, `aria-level`,
+ * `aria-posinset`, `aria-setsize`, `aria-expanded`, `aria-disabled`, and `data-active`,
+ * `data-disabled`, `data-expanded` hooks for styling). Roles and selection attributes
+ * (`role="treeitem"`, `aria-selected`, `aria-checked`) stay with the consuming component.
+ * Turn the ARIA attributes off with `[manageAria]="false"` when the component binds them itself.
+ *
+ * ```html
+ * <!-- Flat rows, as a virtual list renders them -->
+ * <div role="treeitem"
+ *      [andesTreeNavigationItem]="row.key"
+ *      [parentKey]="row.parentKey"
+ *      [expandable]="row.hasChildren">
+ *   {{ row.title }}
+ * </div>
+ *
+ * <!-- Nested markup: the parent is the enclosing item -->
+ * <li role="treeitem" [andesTreeNavigationItem]="'docs'">
+ *   Docs
+ *   <ul role="group">
+ *     <li role="treeitem" [andesTreeNavigationItem]="'docs/api'">API</li>
+ *   </ul>
+ * </li>
+ * ```
+ */
+declare class AndesTreeNavigationItem implements AndesTreeNavigationItemRef, OnInit, OnDestroy {
+    /**
+     * The node's unique key. Bound through the directive's own selector so the common case needs
+     * no extra attribute: `[andesTreeNavigationItem]="node.key"`.
+     */
+    readonly key: _angular_core.InputSignal<AndesTreeNavigationKey>;
+    /**
+     * Key of the parent node, or `null` for a root. Leave it unset when items are nested in the
+     * template, in which case the enclosing item is the parent; set it for flat markup, where
+     * nesting is expressed by data rather than by the DOM.
+     */
+    readonly parentKey: _angular_core.InputSignal<AndesTreeNavigationKey | null | undefined>;
+    /** Whether navigation skips the node. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the node can be expanded. Leave it unset to derive it from "has registered
+     * children"; set it for a parent whose children are not rendered yet (collapsed subtrees
+     * that are not in the DOM, lazily loaded children), so that `ArrowRight` can open it.
+     */
+    readonly expandable: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /**
+     * Text typeahead matches against. Defaults to the item's own text content, which is usually
+     * right; set it when the visible text is decorative or split across elements.
+     */
+    readonly typeaheadLabel: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Overrides `aria-level` for trees that render only a slice of the hierarchy and so cannot
+     * count ancestors. By default the level is derived from the parent chain.
+     */
+    readonly level: _angular_core.InputSignalWithTransform<number | undefined, string | number | null | undefined>;
+    /** Overrides `aria-posinset`, e.g. a server-side position in a paged list of siblings. */
+    readonly posInSet: _angular_core.InputSignalWithTransform<number | undefined, string | number | null | undefined>;
+    /** Overrides `aria-setsize`, e.g. the total sibling count of a partly loaded list. */
+    readonly setSize: _angular_core.InputSignalWithTransform<number | undefined, string | number | null | undefined>;
+    /**
+     * Whether the directive writes `aria-level`, `aria-posinset`, `aria-setsize`,
+     * `aria-expanded` and `aria-disabled` to the host. Turn it off when the component binds
+     * them itself, from the signals below.
+     */
+    readonly manageAria: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** @internal Mirrors {@link key} under the name the navigation's item contract uses. */
+    readonly itemKey: Signal<AndesTreeNavigationKey>;
+    /** @internal Mirrors {@link disabled} under the name the navigation's item contract uses. */
+    readonly isDisabled: Signal<boolean>;
+    /** @internal Mirrors {@link expandable} under the name the navigation's item contract uses. */
+    readonly isExpandable: Signal<boolean | undefined>;
+    private readonly navigation;
+    /** The enclosing item of the same tree, when the markup is nested. */
+    private readonly enclosingItem;
+    readonly element: HTMLElement;
+    /** The item's DOM `id` — its own, when it has one, so authored ids are never clobbered. */
+    readonly itemId: string;
+    /** @internal The parent's key as the navigation should see it. */
+    readonly itemParentKey: Signal<AndesTreeNavigationKey | null>;
+    private readonly info;
+    /** Whether this is the navigation's active node. */
+    readonly active: Signal<boolean>;
+    /** Whether the navigation treats this node as disabled. */
+    readonly nodeDisabled: Signal<boolean>;
+    /** Whether the node can be expanded: declared, or because it has children. */
+    readonly isExpandableNode: Signal<boolean>;
+    /** Whether the node is expanded. */
+    readonly expanded: Signal<boolean>;
+    /** `aria-level`: 1 for a root. */
+    readonly ariaLevel: Signal<number>;
+    /** `aria-posinset`: 1-based position among all siblings, collapsed ones included. */
+    readonly ariaPosinset: Signal<number>;
+    /** `aria-setsize`: number of siblings, this node included. */
+    readonly ariaSetsize: Signal<number>;
+    /** `aria-expanded`: `true`/`false` on a parent, `null` on a leaf (the attribute is omitted). */
+    readonly ariaExpanded: Signal<boolean | null>;
+    /**
+     * `0` on the one roving-tabindex target, `-1` on every other node, and absent entirely in
+     * `active-descendant` mode, where nodes are not focusable at all.
+     */
+    readonly tabIndex: Signal<number | null>;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getLabel(): string;
+    focus(): void;
+    /**
+     * Scrolls the node into view without moving focus — what `active-descendant` mode needs,
+     * since real focus never reaches the node.
+     */
+    reveal(): void;
+    /** Expands the node. A chevron button calls this. Returns whether anything changed. */
+    expand(): boolean;
+    /** Collapses the node. Returns whether anything changed. */
+    collapse(): boolean;
+    /** Expands a collapsed node and collapses an expanded one. */
+    toggle(): boolean;
+    protected onFocusin(): void;
+    protected onFocusout(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesTreeNavigationItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AndesTreeNavigationItem, "[andesTreeNavigationItem]", ["andesTreeNavigationItem"], { "key": { "alias": "andesTreeNavigationItem"; "required": true; "isSignal": true; }; "parentKey": { "alias": "parentKey"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "typeaheadLabel": { "alias": "typeaheadLabel"; "required": false; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; "posInSet": { "alias": "posInSet"; "required": false; "isSignal": true; }; "setSize": { "alias": "setSize"; "required": false; "isSignal": true; }; "manageAria": { "alias": "manageAria"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Wires the keyboard-owning element of a tree to its {@link AndesTreeNavigation}: forwards
+ * `keydown` to it and publishes `aria-activedescendant` when the tree is in `active-descendant`
+ * mode.
+ *
+ * Put it on whichever element holds real DOM focus:
+ *
+ * - a tree whose nodes take focus — the `role="tree"` element (keys bubble up from the nodes);
+ * - a cascader or tree-select — the field or the `<input>`, which keeps focus the whole time;
+ * - a menu — the `role="menu"` popup.
+ *
+ * It only consumes navigation keys, so the consumer is free to bind its own `keydown` handler on
+ * the same element for `Enter`, `Space` and `Escape`.
+ *
+ * In a windowed tree the tab stop can fall on a node that is not rendered. Binding
+ * `[attr.tabindex]="navigation.containerTabIndex()"` on the same element then keeps the tree
+ * reachable with Tab, and this directive passes the focus on to the node, scrolling it in.
+ *
+ * ```html
+ * <ul role="tree" andesTreeNavigationKeys (keydown.enter)="activate()">…</ul>
+ * ```
+ */
+declare class AndesTreeNavigationKeys {
+    protected readonly navigation: AndesTreeNavigation;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onFocusin(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesTreeNavigationKeys, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AndesTreeNavigationKeys, "[andesTreeNavigationKeys]", never, {}, {}, never, never, true, never>;
+}
+
+/** The names of Andes' responsive breakpoints. */
+type AndesBreakpoint = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+/** Breakpoint names, smallest first. */
+declare const ANDES_BREAKPOINT_NAMES: readonly AndesBreakpoint[];
+/**
+ * The minimum viewport (or container) width, in pixels, at which each breakpoint starts.
+ * Breakpoints are cumulative and mobile-first: `md` applies from 768px up, until `lg` takes
+ * over. One table shared by every component keeps "mobile" meaning the same width everywhere.
+ */
+declare const ANDES_BREAKPOINTS: Readonly<Record<AndesBreakpoint, number>>;
+/**
+ * The largest breakpoint whose minimum width fits `width`. Negative and `NaN` widths count as
+ * `xs`.
+ */
+declare function andesBreakpointForWidth(width: number): AndesBreakpoint;
+/**
+ * The breakpoint reported where the viewport cannot be measured (server rendering, browsers
+ * without `matchMedia`). Override it to match your most common client so the server-rendered
+ * markup is the one most users keep.
+ */
+declare const ANDES_BREAKPOINT_SSR_DEFAULT: InjectionToken<AndesBreakpoint>;
+/**
+ * The current viewport breakpoint and ready-made "at least / narrower than / in range" signals,
+ * shared by the whole application.
+ *
+ * It listens to one `matchMedia` query per breakpoint (never to `resize`), so nothing runs
+ * while the viewport stays inside a breakpoint, and the listeners are removed with the root
+ * injector. On the server, or where `matchMedia` does not exist, `active` holds
+ * `ANDES_BREAKPOINT_SSR_DEFAULT` and never changes.
+ *
+ * The comparisons are half-open on purpose: `up(x)` is true from the start of `x`, `down(x)` is
+ * true strictly before it, so `down(x)` is always `!up(x)` and `between(a, b)` ranges never
+ * overlap or leave a gap when chained (`between('sm', 'md')` then `between('md', 'lg')`).
+ */
+declare class AndesBreakpoints {
+    private readonly state;
+    private readonly comparisons;
+    /** The largest breakpoint whose minimum width the viewport has reached. */
+    readonly active: Signal<AndesBreakpoint>;
+    constructor();
+    /**
+     * True once the viewport is at least as wide as `name` (`up('md')` is true from 768px).
+     * `up('xs')` is always true. Repeated calls with the same name return the same signal.
+     */
+    up(name: AndesBreakpoint): Signal<boolean>;
+    /**
+     * True while the viewport is narrower than `name` (`down('lg')` is true below 992px, the
+     * usual "collapse on small screens" test). `down('xs')` is always false.
+     */
+    down(name: AndesBreakpoint): Signal<boolean>;
+    /**
+     * True from the start of `from` until the start of `to` (`between('sm', 'lg')` covers 576px
+     * up to, but excluding, 992px). A range that is empty or reversed (`from` not below `to`) is
+     * never true, rather than being silently swapped.
+     */
+    between(from: AndesBreakpoint, to: AndesBreakpoint): Signal<boolean>;
+    private memo;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesBreakpoints, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AndesBreakpoints>;
+}
+
+/** Which box of an element is measured. */
+type AndesElementBox = 'content-box' | 'border-box';
+/** A measured width and height, in CSS pixels. */
+interface AndesElementMeasure {
+    readonly width: number;
+    readonly height: number;
+}
+/** Options for {@link AndesResizeObserver.observe}. */
+interface AndesResizeObserveOptions {
+    /**
+     * The box to measure. `content-box` (default) excludes padding and border, which is what a
+     * component laying out its children cares about; `border-box` is the space the element takes
+     * in its parent.
+     */
+    readonly box?: AndesElementBox;
+}
+/**
+ * One shared `ResizeObserver` (per measured box) for every element Andes watches, instead of
+ * each component creating, guarding and disconnecting its own.
+ *
+ * Why it is shared: a single observer delivers all changes of a frame together, and the
+ * bookkeeping that is easy to get wrong in each component (server guard, missing
+ * `ResizeObserver`, disconnect on destroy) lives here once. The native observer is created with
+ * the first subscription and disconnected with the last, so an idle page holds none.
+ *
+ * Why it is coalesced: bursts of changes within a frame (a window being dragged, a loop of
+ * layout-triggered resizes) are reduced to the latest measurement per subscription and
+ * delivered in one animation frame, so consumers write their state once per frame. The first
+ * measurement of a subscription is the exception and is delivered at once, otherwise the first
+ * paint would show the unmeasured state for an extra frame.
+ *
+ * It does nothing on the server or where `ResizeObserver` does not exist.
+ */
+declare class AndesResizeObserver {
+    private readonly browser;
+    private readonly channels;
+    private frame;
+    private readonly dirty;
+    constructor();
+    /**
+     * Calls `callback` with the element's size now (once the browser reports it) and whenever it
+     * changes. Returns the function that stops observing; calling it twice is harmless.
+     */
+    observe(element: Element, callback: (measure: AndesElementMeasure) => void, options?: AndesResizeObserveOptions): () => void;
+    private release;
+    private receive;
+    private deliver;
+    private scheduleFrame;
+    private cancelFrame;
+    private flush;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesResizeObserver, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AndesResizeObserver>;
+}
+
+/** What {@link andesElementSize} can watch: an element, its `ElementRef`, or a signal of either. */
+type AndesElementSizeTarget = Element | ElementRef<Element> | Signal<Element | ElementRef<Element> | null | undefined>;
+/** Options for {@link andesElementSize}. */
+interface AndesElementSizeOptions {
+    /**
+     * The box to measure. `content-box` (default) is the room available to the element's
+     * children; `border-box` is the space the element occupies in its parent.
+     */
+    readonly box?: AndesElementBox;
+    /**
+     * The size reported before the first measurement and on the server, where nothing can be
+     * measured. Defaults to `0 x 0`. Use `measured` to tell a real zero from "not measured yet".
+     */
+    readonly initial?: AndesElementMeasure;
+    /** The injector that owns the observation. Only needed outside an injection context. */
+    readonly injector?: Injector;
+}
+/** The signals returned by {@link andesElementSize}. */
+interface AndesElementSizeRef {
+    /** The element's width in CSS pixels. */
+    readonly width: Signal<number>;
+    /** The element's height in CSS pixels. */
+    readonly height: Signal<number>;
+    /** Width and height together, for reading both without two dependencies. */
+    readonly size: Signal<AndesElementMeasure>;
+    /**
+     * False until the browser has reported a size for the current element, and again whenever the
+     * element goes away or is swapped. Lets callers keep a server-rendered layout rather than
+     * collapse to the `initial` size.
+     */
+    readonly measured: Signal<boolean>;
+}
+/**
+ * Tracks an element's size as signals. Replaces a hand-written `ResizeObserver` plus its
+ * server guard and teardown.
+ *
+ * Observation starts when the element exists and stops when it goes away, is swapped for
+ * another, or the owning injector is destroyed, so a signal target such as a `viewChild` can
+ * come and go freely. All elements share one native observer and updates are coalesced to one
+ * per animation frame (see `AndesResizeObserver`). On the server and where `ResizeObserver` is
+ * missing nothing is observed and the signals keep `initial`.
+ *
+ * Must be called in an injection context unless `options.injector` is given.
+ */
+declare function andesElementSize(target: AndesElementSizeTarget, options?: AndesElementSizeOptions): AndesElementSizeRef;
+
+/** Options for {@link andesContainerBreakpoint}. */
+interface AndesContainerBreakpointOptions<K extends string> extends Pick<AndesElementSizeOptions, 'box' | 'injector'> {
+    /**
+     * The bucket reported before the element is measured and on the server. Defaults to the
+     * smallest bucket, the safe choice for a "collapse when narrow" layout that is then expanded
+     * once the real width is known.
+     */
+    readonly initial?: NoInfer<K>;
+}
+/**
+ * The container-width bucket an element currently falls in, for components that adapt to the
+ * room they are given rather than to the viewport (collapsing pagination, a grid row inside a
+ * narrow sidebar).
+ *
+ * `buckets` maps a name to the minimum width at which it starts, mobile-first like the viewport
+ * breakpoints, so `ANDES_BREAKPOINTS` works as is and `{ compact: 0, full: 480 }` is a
+ * two-state switch. The signal changes only when the element crosses a threshold, not on every
+ * pixel, so effects and templates reading it stay quiet while the element resizes inside a
+ * bucket. Pass a signal for `buckets` when the thresholds come from inputs.
+ *
+ * Must be called in an injection context unless `options.injector` is given.
+ */
+declare function andesContainerBreakpoint<K extends string>(element: AndesElementSizeTarget, buckets: Readonly<Record<K, number>> | Signal<Readonly<Record<K, number>>>, options?: AndesContainerBreakpointOptions<K>): Signal<K>;
+
+/** Options for {@link andesMediaQuery} and the ready-made preference signals. */
+interface AndesMediaQueryOptions {
+    /**
+     * The value reported where the query cannot be evaluated: server rendering, or a browser
+     * without `matchMedia`. It is also what the signal holds until the first evaluation. Defaults
+     * to `false`, i.e. "the condition does not hold", which for preference queries means the
+     * default experience.
+     */
+    readonly ssrDefault?: boolean;
+    /**
+     * The injector that owns the listener. Only needed when calling outside an injection context;
+     * the listener is removed when this injector is destroyed.
+     */
+    readonly injector?: Injector;
+}
+/**
+ * Whether a CSS media query currently matches, as a signal that stays in sync.
+ *
+ * The first value is read synchronously, so the first render already uses the right answer
+ * instead of flashing the default. After that one `change` listener keeps it current; it is
+ * removed when the query changes (a `Signal` query) and when the owning injector is destroyed.
+ * Where `matchMedia` is unavailable the signal holds `ssrDefault` and nothing is registered.
+ *
+ * Must be called in an injection context unless `options.injector` is given.
+ *
+ * @param query A media query string, or a signal of one for queries that depend on an input.
+ */
+declare function andesMediaQuery(query: string | Signal<string>, options?: AndesMediaQueryOptions): Signal<boolean>;
+/**
+ * Whether the user asked the system to reduce motion. Components consult it before running
+ * non-essential animation or smooth scrolling.
+ */
+declare function andesPrefersReducedMotion(options?: AndesMediaQueryOptions): Signal<boolean>;
+/** Whether the system is set to a dark color scheme. */
+declare function andesPrefersDark(options?: AndesMediaQueryOptions): Signal<boolean>;
+/** Whether the user asked for higher contrast than the default. */
+declare function andesPrefersContrast(options?: AndesMediaQueryOptions): Signal<boolean>;
+
+/**
+ * The validation state of the Angular forms control bound to a component's host element,
+ * exposed as signals so a template or `computed()` can react to it without subscribing to
+ * anything.
+ *
+ * Every signal reads `false` / `null` while nothing is bound, so a component used outside a
+ * form behaves exactly as if the control were valid and untouched.
+ */
+interface AndesControlStatus {
+    /** Whether a forms directive is bound to the host and has produced its control. */
+    readonly bound: Signal<boolean>;
+    /** The bound control failed validation. */
+    readonly invalid: Signal<boolean>;
+    /** The bound control passed validation (and has no async validator still running). */
+    readonly valid: Signal<boolean>;
+    /** The user has left the bound control at least once. */
+    readonly touched: Signal<boolean>;
+    /** The value of the bound control was changed from the UI. */
+    readonly dirty: Signal<boolean>;
+    /** An async validator is still running. */
+    readonly pending: Signal<boolean>;
+    /** The bound control is disabled on the forms side. */
+    readonly disabled: Signal<boolean>;
+    /** The bound control's current errors, or `null` when it has none. */
+    readonly errors: Signal<ValidationErrors | null>;
+    /**
+     * `invalid` once the user has interacted (`touched` or `dirty`). This is the usual "do not
+     * shout at someone who has not typed yet" rule, so a component can paint its error state
+     * from it directly instead of the page wiring `aria-invalid` by hand.
+     */
+    readonly showError: Signal<boolean>;
+}
+/** What `injectAndesControlStatus` accepts. */
+interface AndesControlStatusOptions {
+    /**
+     * A signal that changes whenever the forms directive (re)registers this component as its
+     * value accessor. Re-binding a `[formControl]` to a different control registers the accessor
+     * again, and that is the only moment the status has a reason to re-subscribe, because
+     * Angular offers no event for "this directive now points at another control".
+     * `AndesValueAccessor` already supplies it.
+     */
+    readonly rebindOn?: Signal<unknown>;
+}
+/**
+ * Reads the status of the Angular forms control sitting on the same element as the calling
+ * component or directive. Works unchanged with `formControl`, `formControlName`, `ngModel`
+ * and signal forms' `[formField]`.
+ *
+ * Must run in an injection context (a field initializer or constructor).
+ *
+ * The `NgControl` is looked up lazily, from an effect, and never from the constructor. A
+ * component that provides `NG_VALUE_ACCESSOR` cannot `inject(NgControl)` while it is being
+ * constructed: the forms directive injects the accessor to build itself, so the two wait on
+ * each other and Angular reports a circular dependency. By the time the first change
+ * detection pass runs, both exist and the lookup is plain. The cost is that status reads
+ * before that pass see the "unbound" defaults.
+ *
+ * ```ts
+ * @Component({ ... })
+ * class AndesTextbox {
+ *   private readonly status = injectAndesControlStatus();
+ *   protected readonly invalid = computed(() => this.status.showError());
+ * }
+ * ```
+ */
+declare function injectAndesControlStatus(options?: AndesControlStatusOptions): AndesControlStatus;
+
+/**
+ * Base class for a component whose state is a single `value` and that should work with every
+ * kind of Angular form. It owns the `value` model, the `disabled` input, the
+ * `ControlValueAccessor` methods and the status of the bound control, so a subclass only
+ * renders the value and calls {@link commit} when the user changes it.
+ *
+ * ```ts
+ * @Component({
+ *   selector: 'andes-rating',
+ *   providers: [provideAndesValueAccessor(() => AndesRating)],
+ * })
+ * class AndesRating extends AndesFormControlBase<number> {
+ *   protected emptyValue(): number {
+ *     return 0;
+ *   }
+ *   protected pick(stars: number): void {
+ *     this.commit(stars);
+ *   }
+ * }
+ * ```
+ *
+ * The class also satisfies signal forms' custom-control contract (`value` model, `disabled`
+ * input, `touch` output). A subclass that omits `provideAndesValueAccessor` therefore binds
+ * to `[formField]` natively and is simply not usable with reactive or template-driven forms;
+ * one that provides it works with all of them, signal forms going through the accessor.
+ *
+ * It declares the `value` and `disabled` members itself, so a component whose value signal
+ * has another name (`checked`, `pressed`) uses {@link AndesValueAccessor} directly instead.
+ */
+declare abstract class AndesFormControlBase<T> implements ControlValueAccessor {
+    /**
+     * The control's value. A `model()`, so `[(value)]` works beside any forms binding and a
+     * user's pick and a form's write land in the same signal. Note that this means
+     * `valueChange` also fires when a form writes a different value; `commit()` is what tells
+     * the form about changes made by the user.
+     */
+    readonly value: _angular_core.ModelSignal<T>;
+    /** Disables the control. A disabled state pushed by Angular forms disables it as well. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Fires each time the user leaves the control. It is the touched signal of signal forms'
+     * custom-control contract; reactive and template-driven forms are told through their
+     * accessor callback instead.
+     */
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    private readonly accessor;
+    /** `disabled` merged with the disabled state of the bound form control. */
+    protected readonly isDisabled: Signal<boolean>;
+    /** The validation state of the bound form control; see {@link AndesControlStatus}. */
+    protected readonly status: AndesControlStatus;
+    constructor();
+    /**
+     * What the control holds before a form writes anything, and what a form's `null` /
+     * `undefined` (a `reset()`) means: `''` for text, `[]` for a multi-select. A method rather
+     * than a constant so that every control gets its own array or object. It runs while the
+     * base class is being constructed, so it must not read the subclass's own fields.
+     */
+    protected abstract emptyValue(): T;
+    /**
+     * Applies a value chosen by the user and notifies Angular forms exactly once. Does nothing,
+     * and returns `false`, when {@link equals} says nothing changed.
+     */
+    protected commit(value: T): boolean;
+    /** Reports that the user left the control. Call it on blur. */
+    protected markTouched(): void;
+    /**
+     * Turns what a form writes into a `T`. By default `null` / `undefined` become the empty
+     * value and everything else passes through unchanged. Override
+     * it to normalize (`String(raw)`, clamping) or to make the empty value depend on inputs.
+     */
+    protected coerce(raw: unknown): T;
+    /**
+     * Whether two values are the same for the purpose of {@link commit}. `Object.is` by
+     * default; override it for array and object values.
+     */
+    protected equals(previous: T, next: T): boolean;
+    /**
+     * Called after a form wrote a value, to refresh state derived from it. Never reported back
+     * to the form.
+     */
+    protected onWritten(value: T): void;
+    /** Called by Angular forms to write a value into the control; never echoes back. */
+    writeValue(raw: unknown): void;
+    /** Called by Angular forms to receive value changes made by the user. */
+    registerOnChange(fn: (value: T) => void): void;
+    /** Called by Angular forms to receive the touched notification. */
+    registerOnTouched(fn: () => void): void;
+    /** Called by Angular forms when the bound control is enabled or disabled. */
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesFormControlBase<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AndesFormControlBase<any>, never, never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * Registers a component as the `ControlValueAccessor` of the forms directive on its element,
+ * replacing the `{ provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(...), multi: true }`
+ * block each component repeated. The component is passed as a thunk so the class can be
+ * referenced from its own decorator, which is what the `forwardRef` was for.
+ *
+ * With only the component, the component itself must implement `ControlValueAccessor`
+ * (extending `AndesFormControlBase` does). Pass `select` to register a different object, such
+ * as an `AndesValueAccessor` the component owns, so the component's public API does not grow
+ * `writeValue` and friends.
+ *
+ * Because a value accessor is registered, signal forms' `[formField]` binds through it too,
+ * so one provider covers `formControl`, `formControlName`, `ngModel` and `[formField]`.
+ *
+ * ```ts
+ * @Component({
+ *   selector: 'andes-rating',
+ *   providers: [provideAndesValueAccessor(() => AndesRating)],
+ * })
+ * class AndesRating extends AndesFormControlBase<number> { ... }
+ * ```
+ */
+declare function provideAndesValueAccessor<C extends ControlValueAccessor>(component: () => Type<C>): Provider;
+declare function provideAndesValueAccessor<C>(component: () => Type<C>, select: (instance: C) => ControlValueAccessor): Provider;
+
+/** What `AndesValueAccessor` needs to know about the component it serves. */
+interface AndesValueAccessorOptions<T> {
+    /**
+     * The signal that holds the control's value: usually the component's `model()`, but any
+     * writable signal works, including a `linkedSignal`. The accessor writes to it for both
+     * user commits and form writes, so there is one source of truth to render from.
+     */
+    readonly value: WritableSignal<T>;
+    /**
+     * The component's own `disabled` input. It is merged with the disabled state Angular forms
+     * pushes in, so either side can disable the control, as with a native `<fieldset>`.
+     */
+    readonly disabled?: Signal<boolean>;
+    /**
+     * Decides whether a commit actually changes the value. A commit that does not is dropped,
+     * so re-picking the selected option never marks the control dirty. Defaults to `Object.is`;
+     * array and object values need their own comparison (see {@link andesShallowArrayEquals}).
+     */
+    readonly equals?: (previous: T, next: T) => boolean;
+    /**
+     * What a form's `null` / `undefined` (a `reset()`, an unset model) means for this control,
+     * for example `''` for text or `[]` for a multi-select. Treated as immutable. Ignored when
+     * `coerce` is given.
+     */
+    readonly emptyValue?: T;
+    /**
+     * Turns whatever a form writes into a value of type `T`, e.g. `String(value)` or clamping a
+     * number. Takes precedence over `emptyValue`.
+     */
+    readonly coerce?: (raw: unknown) => T;
+    /**
+     * Runs after a form wrote a value, for state derived from it that is not itself the value:
+     * the text shown in a field, a discarded draft. It runs on writes only, never on commits,
+     * and nothing it does is reported back to the form.
+     */
+    readonly onWrite?: (value: T) => void;
+    /** Runs each time the control is marked touched, so a component can surface it as an output. */
+    readonly onTouch?: () => void;
+}
+/**
+ * Shallow, order-sensitive equality for array values, treating `null` / `undefined` as the
+ * empty array. Pass it as `equals` for multi-value controls so that committing an array with
+ * the same items does not count as a change.
+ */
+declare function andesShallowArrayEquals<T>(previous: readonly T[] | null | undefined, next: readonly T[] | null | undefined): boolean;
+/**
+ * The `ControlValueAccessor` plumbing every value-holding component re-implements, as one
+ * object a component owns rather than inherits. Use it directly when the value signal is not
+ * called `value` or the component already extends another class; extend
+ * {@link AndesFormControlBase} when it is.
+ *
+ * It encodes the contract the duplicated code kept getting subtly wrong:
+ *
+ * - `commit()` sets the signal and tells the form, once, and only if the value changed;
+ * - `writeValue()` sets the signal but never tells the form back, so `setValue()` /
+ *   `reset()` cannot loop;
+ * - `disabled` is the component's input OR the form's state, whichever says so;
+ * - `markTouched()` is forwarded every time, because `updateOn: 'blur'` controls only
+ *   publish their pending value from that call.
+ *
+ * Must be created in an injection context. After the component is destroyed it stops
+ * notifying the form.
+ *
+ * ```ts
+ * @Component({
+ *   selector: 'andes-switch',
+ *   providers: [provideAndesValueAccessor(() => AndesSwitch, (self) => self.accessor)],
+ * })
+ * class AndesSwitch {
+ *   readonly checked = model(false);
+ *   readonly disabled = input(false, { transform: booleanAttribute });
+ *   readonly accessor = new AndesValueAccessor({
+ *     value: this.checked,
+ *     disabled: this.disabled,
+ *     coerce: Boolean,
+ *   });
+ *
+ *   protected toggle(): void {
+ *     this.accessor.commit(!this.checked());
+ *   }
+ * }
+ * ```
+ */
+declare class AndesValueAccessor<T> implements ControlValueAccessor {
+    private readonly options;
+    private onChange;
+    private onTouched;
+    private destroyed;
+    private readonly disabledByForm;
+    private readonly registrations;
+    /** The component's value signal, as passed in. */
+    readonly value: WritableSignal<T>;
+    /** The component's own `disabled` input OR'd with the state Angular forms pushed in. */
+    readonly disabled: Signal<boolean>;
+    /** The validation state of the bound forms control; see {@link AndesControlStatus}. */
+    readonly status: AndesControlStatus;
+    constructor(options: AndesValueAccessorOptions<T>);
+    /**
+     * Applies a value chosen by the user: updates the signal and notifies Angular forms,
+     * exactly once. Returns `false`, doing nothing, when `value` equals the current one.
+     *
+     * It does not look at `disabled`: the component decides whether an interaction may happen
+     * at all, because only it knows which interactions count (a disabled control may still
+     * scroll or expand).
+     */
+    commit(value: T): boolean;
+    /**
+     * Tells Angular forms the user has left the control. Call it on blur, and when an
+     * interaction ends without a blur (a popup closing). Safe to call repeatedly.
+     */
+    markTouched(): void;
+    /**
+     * Called by Angular forms to put a value into the control. Updates the signal and runs
+     * `onWrite`, and never reports back to the form.
+     */
+    writeValue(raw: unknown): void;
+    /** Called by Angular forms to receive value changes made by the user. */
+    registerOnChange(fn: (value: T) => void): void;
+    /** Called by Angular forms to receive the touched notification. */
+    registerOnTouched(fn: () => void): void;
+    /** Called by Angular forms when the bound control is enabled or disabled. */
+    setDisabledState(isDisabled: boolean): void;
+}
+
+/**
+ * How many items a selection may hold.
+ *
+ * - `single` — at most one item; selecting another replaces it (radio-like lists, a single
+ *   select, a table with radio selection).
+ * - `multiple` — any number of items, bounded only by `max` (checkbox groups, multi selects,
+ *   transfer lists, tables with checkbox selection).
+ */
+type AndesSelectionMode = 'single' | 'multiple';
+/**
+ * Aggregate state of a selection over a list of items — what a "select all" control renders.
+ *
+ * - `none` — no considered item is selected (also the answer when nothing is considered).
+ * - `some` — a strict subset is selected: the "mixed" / indeterminate state.
+ * - `all` — every considered item is selected.
+ */
+type AndesSelectionState = 'none' | 'some' | 'all';
+/**
+ * Where a change came from.
+ *
+ * Forms integrations need the distinction: an `interaction` (the user clicked, a key was
+ * pressed) must be reported to the form, while a `programmatic` write (a form pushing its own
+ * value in, a source list being reconciled) must not be echoed back at it.
+ */
+type AndesSelectionChangeSource = 'interaction' | 'programmatic';
+/**
+ * What one mutation changed. Membership only: a call that merely refreshes object instances
+ * or reorders the same members reports nothing.
+ */
+interface AndesSelectionChange<T> {
+    /** Items that became selected, in the order they were added. */
+    readonly added: readonly T[];
+    /** Items that stopped being selected, in their former selection order. */
+    readonly removed: readonly T[];
+    /** Whether the change was an `interaction` or a `programmatic` write. */
+    readonly source: AndesSelectionChangeSource;
+}
+/** Options for {@link AndesSelectionModel}. Every key is optional. */
+interface AndesSelectionModelConfig<T> {
+    /**
+     * Single or multiple selection; a `Signal` keeps the model in step with a component input.
+     * Switching to `single` while several items are selected shows only the earliest one
+     * selected. Default `'multiple'`.
+     */
+    mode?: AndesSelectionMode | Signal<AndesSelectionMode>;
+    /**
+     * The most items `multiple` mode may hold; `undefined` means no limit. Lowering it below the
+     * current size shows only the earliest items selected. Default `undefined`.
+     */
+    max?: number | undefined | Signal<number | undefined>;
+    /**
+     * Maps an item to the value used to tell items apart (an id, a path string). Use it when
+     * the same logical item can arrive as different object instances — rows re-fetched from a
+     * server, options rebuilt on every change detection. It is hashed, so lookups stay O(1)
+     * with thousands of items. Default: the item itself.
+     */
+    keyOf?: (item: T) => unknown;
+    /**
+     * Escape hatch for equality that cannot be reduced to a key. Every lookup scans the
+     * selection, so prefer `keyOf` for large selections. Ignored when `keyOf` is given.
+     */
+    compareWith?: (a: T, b: T) => boolean;
+    /**
+     * Marks items the user cannot change: selecting, deselecting, clearing or range-selecting
+     * them does nothing, and "select all" ignores them. It may read signals; the model's
+     * derived state tracks them. Programmatic writes (`setSelection`) bypass it so a form can
+     * still pre-select a disabled option.
+     */
+    isDisabled?: (item: T) => boolean;
+    /** Items selected from the start, without reporting a change. */
+    initial?: readonly T[];
+    /**
+     * Called synchronously after every change, with the same object that `changes` publishes.
+     * Components use it to emit an output at the exact moment the selection changes.
+     */
+    onChange?: (change: AndesSelectionChange<T>) => void;
+}
+/**
+ * Check state of one tree node, mirroring `aria-checked`.
+ *
+ * `mixed` is a parent with some, but not all, of its checkable descendants checked.
+ */
+type AndesCheckState = 'checked' | 'unchecked' | 'mixed';
+/**
+ * Which checked nodes a consumer wants reported when parents cascade.
+ *
+ * - `all` — every checked node, parents included.
+ * - `parent` — only the topmost checked nodes: a checked folder stands for its whole subtree.
+ * - `child` — only checked nodes without children (the leaves).
+ */
+type AndesCheckedStrategy = 'all' | 'parent' | 'child';
+/** Options for {@link AndesCheckedTree}. */
+interface AndesCheckedTreeConfig<T, K = T> {
+    /**
+     * The root nodes, or a function (typically a signal) returning them. Read reactively: when
+     * it returns a new array the tree is re-indexed. Treat nodes as immutable — mutating a
+     * `children` array in place is not noticed.
+     */
+    nodes: readonly T[] | (() => readonly T[]);
+    /**
+     * Reads a node's children. Nodes without a children field can return `undefined`.
+     */
+    childrenOf: (node: T) => readonly T[] | null | undefined;
+    /**
+     * Identifies a node. Keys must be unique: when a key repeats, the first node wins and the
+     * later one (with its subtree) is ignored, which also makes cyclic data harmless.
+     * Default: the node itself.
+     */
+    keyOf?: (node: T) => K;
+    /**
+     * Locks a node's checkbox. A locked node keeps whatever state it has, cannot be toggled by
+     * the user, and takes no part in propagation: a cascade neither reaches it (nor anything
+     * below it) and its state is ignored when a parent aggregates its children.
+     */
+    isDisabled?: (node: T) => boolean;
+    /**
+     * `true` makes every node independent (no propagation in either direction); a `Signal`
+     * keeps the tree in step with a component input. Default `false`.
+     */
+    strict?: boolean | Signal<boolean>;
+    /** Keys checked from the start, without reporting a change. */
+    initial?: readonly K[];
+    /** Called synchronously after every change, with the same object `changes` publishes. */
+    onChange?: (change: AndesSelectionChange<K>) => void;
+}
+
+/**
+ * Check state for a hierarchy — a tree, a cascader with multiple values, or a table whose rows
+ * have child rows — with parent/child propagation.
+ *
+ * Checking a node checks everything below it; a parent is checked once all its children are and
+ * is `mixed` (half-checked) while only some are. The `strict` option turns propagation off so
+ * every node is independent. Locked nodes (`isDisabled`) are islands: they keep their state and
+ * neither receive nor pass on a cascade, so a parent aggregates only its unlocked children and
+ * a partially locked parent can still be checked by its available children alone.
+ *
+ * The model stores keys, not nodes, because a checked value usually arrives from a form or a
+ * lazy-loading source before (or without) the node being present. Keys that match no node are
+ * kept and reported by `checkedKeys` until {@link prune} removes them, so a source list that
+ * is temporarily empty or paged does not erase the value. The index is rebuilt once per
+ * `nodes` change and every update is a single linear pass, which keeps a few thousand nodes
+ * instantaneous.
+ *
+ * ```ts
+ * readonly tree = new AndesCheckedTree<Folder, string>({
+ *   nodes: this.folders,              // a signal
+ *   childrenOf: (folder) => folder.children,
+ *   keyOf: (folder) => folder.id,
+ *   strict: this.checkStrictly,       // a signal input
+ *   onChange: (change) => this.checkedChange.emit(change),
+ * });
+ * // template: [checked]="tree.stateOf(id) === 'checked'" [indeterminate]="tree.stateOf(id) === 'mixed'"
+ * ```
+ */
+declare class AndesCheckedTree<T, K = T> {
+    private readonly nodesSource;
+    private readonly childrenOf;
+    private readonly keyOf;
+    private readonly disabledPredicate;
+    private readonly onChange;
+    private readonly raw;
+    private readonly lastChange;
+    private readonly index;
+    private readonly locked;
+    private readonly flags;
+    private readonly unknownKeys;
+    /** Whether propagation is off. */
+    readonly strict: Signal<boolean>;
+    /** Every checked node's key, parents included, in tree order. */
+    readonly checked: Signal<ReadonlySet<K>>;
+    /** Keys of parents with some, but not all, unlocked children checked. Always empty when strict. */
+    readonly halfChecked: Signal<ReadonlySet<K>>;
+    /**
+     * The checked value: {@link checked} in tree order, followed by keys that match no node
+     * (kept until {@link prune}). This is what a form control or two-way binding holds.
+     */
+    readonly checkedKeys: Signal<readonly K[]>;
+    /**
+     * Summary over every unlocked node: `all` when each is checked, `none` when none is, `some`
+     * otherwise. Drives a tree-wide "select all" checkbox.
+     */
+    readonly overallState: Signal<AndesSelectionState>;
+    /** The most recent change, or `null`. A fresh object per change; see `AndesSelectionModel.changes`. */
+    readonly changes: Signal<AndesSelectionChange<K> | null>;
+    constructor(config: AndesCheckedTreeConfig<T, K>);
+    /** Whether the tree has a node with this key. */
+    has(key: K): boolean;
+    /** The key of a node's parent, or `undefined` for roots and unknown keys. */
+    parentKeyOf(key: K): K | undefined;
+    /** The keys of a node's children, in source order; empty for leaves and unknown keys. */
+    childKeysOf(key: K): readonly K[];
+    /** Whether the node is locked by `isDisabled`. Unknown keys are not locked. */
+    isDisabled(key: K): boolean;
+    /** Whether the node is fully checked. */
+    isChecked(key: K): boolean;
+    /** Whether the node is a parent with only some of its children checked. */
+    isHalfChecked(key: K): boolean;
+    /** The node's state, shaped for `aria-checked`. Unknown keys are `unchecked`. */
+    stateOf(key: K): AndesCheckState;
+    /**
+     * The checked keys narrowed to what a consumer wants reported: `all` (the default), `parent`
+     * (a checked folder stands for its subtree) or `child` (leaves only). Strict mode has no
+     * hierarchy to collapse, so it always reports everything. Keys with no node are appended
+     * unchanged in every strategy because they cannot be classified.
+     */
+    checkedKeysByStrategy(strategy: AndesCheckedStrategy): readonly K[];
+    /**
+     * Checks a node (and, unless strict, everything below it). Does nothing for an unknown key,
+     * a locked node, or a node that is already checked.
+     *
+     * @returns whether the checked value changed.
+     */
+    check(key: K): boolean;
+    /**
+     * Unchecks a node, everything reachable below it and, unless strict, the ancestors that were
+     * checked only because this node was — which then become `mixed` if siblings stay checked.
+     * A `mixed` parent is unchecked too. Does nothing for an unknown or locked key, or a node
+     * with nothing checked in it.
+     *
+     * @returns whether the checked value changed.
+     */
+    uncheck(key: K): boolean;
+    /**
+     * Flips a node: a `checked` node is unchecked; `unchecked` and `mixed` ones are checked, which
+     * is what completes a half-checked parent on click.
+     *
+     * @returns whether the checked value changed.
+     */
+    toggle(key: K): boolean;
+    /**
+     * Checks every unlocked node. Locked nodes keep their state.
+     *
+     * @returns whether the checked value changed.
+     */
+    checkAll(): boolean;
+    /**
+     * Unchecks every unlocked node and forgets keys that match no node; a locked checked node
+     * stays checked, since the user cannot change it.
+     *
+     * @returns whether the checked value changed.
+     */
+    clear(): boolean;
+    /**
+     * Replaces the checked value, as a form or a two-way binding writes it in. The keys are taken
+     * as the seed: unless strict, a listed parent checks its whole subtree and a parent whose
+     * children are all listed becomes checked. Locking is ignored. Keys with no node are kept.
+     *
+     * Reports `source: 'programmatic'`.
+     *
+     * @returns whether the checked value changed.
+     */
+    setChecked(keys: readonly K[]): boolean;
+    /**
+     * Forgets keys that match no node. Call it after the source list shrinks and the leftover
+     * value should not be reported any more. Reports `source: 'programmatic'`.
+     *
+     * @returns whether any key was dropped.
+     */
+    prune(): boolean;
+    private keysWhere;
+    private setNode;
+    /**
+     * The single write path: runs propagation on `seed`, stores the normalized keys (so the stored
+     * value is always the full checked set, parents included) and publishes `{added, removed}`
+     * relative to the previous `checkedKeys`.
+     */
+    private commit;
+}
+
+/**
+ * A signal-based selection over a list of items: single or multiple, with a maximum, per-item
+ * locking, object identity by key, change reporting, shift-click ranges and the tri-state
+ * "select all" summary.
+ *
+ * It is plain TypeScript state — no DOM, no injection context — so any component, directive or
+ * service can own one. The recurring shapes it replaces are a table's row selection, a
+ * checkbox group, a transfer list's two panes, a multi-select's value and a list's selected
+ * rows.
+ *
+ * Every mutating method returns whether the selection actually changed, so a caller can skip
+ * emitting an output for a click that was blocked or redundant. Interaction methods
+ * (`select`, `deselect`, `toggle`, `clear`, `selectAll`, `deselectAll`, `toggleAll`,
+ * `invert`, `selectRange`) honor `isDisabled` and `max`; `setSelection` and `retainOnly` are
+ * programmatic and do not.
+ *
+ * ```ts
+ * readonly rows = signal<readonly Row[]>([]);
+ * readonly selection = new AndesSelectionModel<Row>({
+ *   keyOf: (row) => row.id,
+ *   isDisabled: (row) => row.locked,
+ *   onChange: (change) => this.selectionChange.emit(change),
+ * });
+ * readonly headerState = computed(() => this.selection.stateOf(this.rows()));
+ *
+ * onRowClick(row: Row, event: MouseEvent) {
+ *   if (event.shiftKey && this.selection.anchor()) {
+ *     this.selection.selectRange(this.rows(), this.selection.anchor()!, row, !this.selection.isSelected(row));
+ *   } else {
+ *     this.selection.toggle(row);
+ *   }
+ * }
+ * ```
+ */
+declare class AndesSelectionModel<T> {
+    private readonly keyOf;
+    private readonly compareWith;
+    private readonly disabledPredicate;
+    private readonly onChange;
+    private readonly raw;
+    private readonly lastChange;
+    private readonly anchorItem;
+    /** Current mode. */
+    readonly mode: Signal<AndesSelectionMode>;
+    /** The effective limit of `multiple` mode, or `undefined` for none. */
+    readonly max: Signal<number | undefined>;
+    /**
+     * The selected items in the order they were selected. Never longer than the mode and `max`
+     * allow, even if those were lowered after items were selected: the extra, later items are
+     * simply not part of the selection any more.
+     */
+    readonly selected: Signal<readonly T[]>;
+    /** Number of selected items. */
+    readonly size: Signal<number>;
+    /** Whether nothing is selected. */
+    readonly isEmpty: Signal<boolean>;
+    /**
+     * The most recent change, or `null` before the first one. Each change is a fresh object, so
+     * an `effect` reading this runs once per change — including two consecutive changes that
+     * add the same item. Unchanged calls never publish.
+     */
+    readonly changes: Signal<AndesSelectionChange<T> | null>;
+    /**
+     * The item the last interaction targeted — the starting point of a shift-click range.
+     * Blocked interactions (a disabled item) leave it alone.
+     */
+    readonly anchor: Signal<T | undefined>;
+    private readonly limit;
+    private readonly selectedLookup;
+    constructor(config?: AndesSelectionModelConfig<T>);
+    /** Whether `item` is selected. Reactive when called from a `computed` or a template. */
+    isSelected(item: T): boolean;
+    /** Whether `isDisabled` locks `item`. Reactive if the predicate reads signals. */
+    isDisabled(item: T): boolean;
+    /**
+     * Selects `item`. In `single` mode it replaces the current item, unless that one is locked.
+     * In `multiple` mode it is refused once `max` is reached.
+     *
+     * @returns whether the selection changed.
+     */
+    select(item: T): boolean;
+    /**
+     * Deselects `item`; a locked item stays selected.
+     *
+     * @returns whether the selection changed.
+     */
+    deselect(item: T): boolean;
+    /**
+     * Flips `item`. In `single` mode a selected item is deselected too, so a list can be
+     * emptied by clicking its selected row; use `select` for radio behavior.
+     *
+     * @returns whether the selection changed.
+     */
+    toggle(item: T): boolean;
+    /**
+     * Deselects everything the user is allowed to change. Locked items stay: a "clear" button
+     * must not silently drop a mandatory choice.
+     *
+     * @returns whether the selection changed.
+     */
+    clear(): boolean;
+    /**
+     * Replaces the selection, as a form or a two-way binding writes a value in. Duplicates are
+     * dropped (the first wins), the list is cut to what the mode and `max` allow, and locking
+     * is ignored — a disabled option can still be pre-selected.
+     *
+     * Unlike the interaction methods this reports `source: 'programmatic'`.
+     *
+     * @returns whether membership changed. Swapping in new object instances for the same keys
+     * updates `selected()` but returns `false` and publishes no change.
+     */
+    setSelection(items: readonly T[]): boolean;
+    /**
+     * Drops selected items that are not in `items`, keeping the order of the rest. Call it when
+     * the source list loses entries and the selection must not point at ghosts. Locking is
+     * ignored: a row that no longer exists cannot stay selected just because it was locked.
+     *
+     * @returns whether anything was dropped.
+     */
+    retainOnly(items: readonly T[]): boolean;
+    /**
+     * Selects every unlocked item of `items`. With `max` it fills the remaining room in list
+     * order and stops, rather than refusing the whole call, so "select all" on a long list
+     * still does something useful. Does nothing in `single` mode, where "all" has no meaning.
+     *
+     * @returns whether the selection changed.
+     */
+    selectAll(items: readonly T[]): boolean;
+    /**
+     * Deselects every unlocked item of `items`. Selected items outside `items`, and locked ones,
+     * are untouched — which is what lets one pane's "select none" leave another pane alone.
+     *
+     * @returns whether the selection changed.
+     */
+    deselectAll(items: readonly T[]): boolean;
+    /**
+     * The header checkbox's click: deselects the unlocked items of `items` when all of them are
+     * selected, otherwise selects them. If selecting changes nothing because `max` is already
+     * reached, it deselects instead, so the control can never get stuck in the mixed state.
+     * Does nothing in `single` mode.
+     *
+     * @returns whether the selection changed.
+     */
+    toggleAll(items: readonly T[]): boolean;
+    /**
+     * Flips the selection of every unlocked item of `items`: selected ones are deselected and the
+     * rest selected (a table's "invert selection"). Items outside `items` and locked items are
+     * untouched. With `max`, newly selected items fill whatever room is left, in list order.
+     * Does nothing in `single` mode.
+     *
+     * @returns whether the selection changed.
+     */
+    invert(items: readonly T[]): boolean;
+    /**
+     * Applies shift-click semantics: every unlocked item between `from` and `to` (inclusive, in
+     * the order of `items`, whichever comes first) is selected, or deselected with
+     * `selected = false`. Callers pass the item that was last interacted with, normally
+     * {@link anchor}, as `from`, and take `selected` from the item being clicked, so a range
+     * extends whatever the click would have done on its own.
+     *
+     * `to` becomes the new anchor. If either item is not in `items` nothing happens; in `single`
+     * mode only `to` is acted on.
+     *
+     * @returns whether the selection changed.
+     */
+    selectRange(items: readonly T[], from: T, to: T, selected?: boolean): boolean;
+    /**
+     * Summarizes the selection over `items`: `all` when every unlocked item is selected, `none`
+     * when none is, `some` otherwise. Locked items and repeated items are not counted — a locked
+     * item can never be changed by "select all", so counting it would leave the control
+     * mixed forever. Items selected but absent from `items` are ignored, so a filtered page
+     * reports on what it shows.
+     *
+     * With a `max` below the number of unlocked items `all` is unreachable; see {@link toggleAll}.
+     *
+     * Reactive: wrap it in `computed(() => model.stateOf(items()))` for a list signal.
+     */
+    stateOf(items: readonly T[]): AndesSelectionState;
+    /** Whether {@link stateOf} is `all`: a "select all" checkbox is checked. */
+    allSelected(items: readonly T[]): boolean;
+    /**
+     * Whether {@link stateOf} is `some`: a strict subset is selected, i.e. the checkbox is
+     * indeterminate. It is `false` for an empty or complete selection.
+     */
+    someSelected(items: readonly T[]): boolean;
+    /** Sets the shift-click anchor directly, for example after a programmatic focus move. */
+    setAnchor(item: T | undefined): void;
+    private addOne;
+    private removeOne;
+    private addMany;
+    private removeMany;
+    /**
+     * The single write path: derives `{added, removed}` by membership, stores the new array and
+     * publishes the change. A call that only swaps instances or reorders members is stored but
+     * stays silent.
+     */
+    private apply;
+    private clip;
+    private dedupe;
+    private same;
+    private createLookup;
+}
+
+/**
+ * Named stacking layer. Each value maps 1:1 onto an `--andes-z-index-*` token in
+ * `@andes-ng/tokens`, so overlay stacking is a token decision, not a magic number
+ * picked per component.
+ */
+type AndesOverlayLayer = 'dropdown' | 'overlay' | 'modal' | 'popover' | 'tooltip' | 'toast';
+/**
+ * Numeric fallbacks that mirror the current `--andes-z-index-*` token values. They are
+ * only used when `@andes-ng/tokens`' `theme.css` is not loaded, so an overlay still
+ * stacks in the right order instead of collapsing to `auto`.
+ */
+declare const ANDES_OVERLAY_Z_INDEX_FALLBACKS: Readonly<Record<AndesOverlayLayer, number>>;
+/** The CSS value applied as `z-index` for a layer, token first, numeric fallback second. */
+declare function andesOverlayZIndex(layer: AndesOverlayLayer): string;
+/** The CSS value applied as the backdrop scrim's background. */
+declare const ANDES_OVERLAY_SCRIM = "var(--andes-color-overlay, rgb(15 23 42 / 45%))";
+/** Side of the anchor an anchored overlay prefers to render on. */
+type AndesOverlaySide = 'top' | 'bottom' | 'left' | 'right';
+/** Alignment of an anchored overlay along its side. */
+type AndesOverlayAlign = 'start' | 'center' | 'end';
+/** Viewport edge an edge-anchored overlay (Drawer/Sheet) slides in from. */
+type AndesOverlayEdge = 'top' | 'right' | 'bottom' | 'left';
+/**
+ * Anchor-relative positioning, for Popover / Tooltip / Dropdown Menu. Collision
+ * handling (flip to the opposite side, then shift along the cross axis) is on by
+ * default — an overlay that would render off-screen is a bug, not a variant.
+ */
+interface AndesOverlayAnchoredPositioning {
+    readonly kind: 'anchored';
+    /** Preferred side. Default `'bottom'`. */
+    readonly side?: AndesOverlaySide;
+    /** Alignment along the side. Default `'center'`. */
+    readonly align?: AndesOverlayAlign;
+    /** Gap in px between anchor and overlay along the side axis. Default `0`. */
+    readonly sideOffset?: number;
+    /** Extra px offset along the alignment axis. Default `0`. */
+    readonly alignOffset?: number;
+    /** Flip to the opposite side when the preferred one does not fit. Default `true`. */
+    readonly flip?: boolean;
+    /**
+     * When flipping, also try the two perpendicular sides once neither the preferred side
+     * nor its opposite fits. Default `true`. A list dropping down from a field turns this
+     * off: placed beside the field it no longer reads as that field's list, so it stays
+     * above or below and is shifted into view instead.
+     */
+    readonly crossSideFallback?: boolean;
+    /** Shift along the cross axis to stay on screen. Default `true`. */
+    readonly shift?: boolean;
+    /** Minimum px kept between the overlay and the viewport edge. Default `8`. */
+    readonly viewportMargin?: number;
+    /** Size the overlay to the anchor's width (Select/Combobox-style). Default `false`. */
+    readonly matchAnchorWidth?: boolean;
+    /** Never re-position after the first open, even on scroll. Default `false`. */
+    readonly lockPosition?: boolean;
+}
+/** Viewport-centered positioning, for Dialog / Alert Dialog. */
+interface AndesOverlayCenteredPositioning {
+    readonly kind: 'centered';
+}
+/** Edge-pinned positioning, for Drawer / Sheet. */
+interface AndesOverlayEdgePositioning {
+    readonly kind: 'edge';
+    /** Which viewport edge to pin to. Default `'right'`. */
+    readonly edge?: AndesOverlayEdge;
+}
+type AndesOverlayPositioning = AndesOverlayAnchoredPositioning | AndesOverlayCenteredPositioning | AndesOverlayEdgePositioning;
+/** Why an overlay closed. Forwarded to consumers so they can veto or branch on it. */
+type AndesOverlayCloseReason = 'imperative' | 'escape-key' | 'outside-click' | 'backdrop-click' | 'close-button' | 'trigger' | 'destroyed';
+/** What receives focus when the overlay opens. */
+type AndesOverlayAutoFocus = 
+/** The first tabbable element inside the overlay (honours `cdkFocusInitial`). */
+'first-tabbable'
+/** The overlay pane itself, via `tabindex="-1"`. */
+ | 'container'
+/** Nothing — focus stays where the user left it. Correct for Tooltip. */
+ | 'none';
+/** ARIA role applied to the overlay content by `AndesOverlayContentPrimitive`. */
+type AndesOverlayRole = 'dialog' | 'alertdialog' | 'menu' | 'listbox' | 'tooltip' | 'none';
+/** Explicit sizing forwarded to the CDK overlay pane. */
+interface AndesOverlaySize {
+    readonly width?: number | string;
+    readonly height?: number | string;
+    readonly minWidth?: number | string;
+    readonly minHeight?: number | string;
+    readonly maxWidth?: number | string;
+    readonly maxHeight?: number | string;
+}
+/**
+ * The full behavior contract of an andes-ng overlay. Every dismissal, focus and
+ * scroll behavior is an independent flag: Dialog wants all of them, Tooltip wants
+ * almost none, and Popover/Dropdown Menu sit in between.
+ */
+interface AndesOverlayConfig {
+    /** Stacking layer, sourced from `--andes-z-index-*`. */
+    readonly layer: AndesOverlayLayer;
+    /** How the overlay is placed. */
+    readonly positioning: AndesOverlayPositioning;
+    /** Keep Tab/Shift+Tab inside the overlay while it is open. */
+    readonly trapFocus: boolean;
+    /** Return focus to the trigger (or the element focused at open time) on close. */
+    readonly restoreFocus: boolean;
+    /** What receives focus when the overlay opens. */
+    readonly autoFocus: AndesOverlayAutoFocus;
+    /** Escape closes the overlay. Only the topmost open overlay reacts. */
+    readonly closeOnEscape: boolean;
+    /** A pointer event outside the overlay (or on its backdrop) closes it. */
+    readonly closeOnOutsideClick: boolean;
+    /** Block document scroll while open. */
+    readonly lockScroll: boolean;
+    /**
+     * Mark everything outside the overlay `inert` while it is open, so a screen
+     * reader browsing the page (not just tabbing through it) cannot reach content
+     * behind a modal. `trapFocus` only governs Tab and `ariaModal` is a hint AT does
+     * not universally honour, so a truly modal overlay needs this as well.
+     *
+     * Applies to every direct child of `<body>` except the one the overlay itself is
+     * portalled into, and is reference-counted across nested overlays.
+     *
+     * On for the `dialog`, `alert-dialog` and `drawer` presets; off for the
+     * non-modal `popover`, `menu` and `tooltip`, which must leave the page usable.
+     */
+    readonly inertBackground: boolean;
+    /** Render a backdrop scrim using `--andes-color-overlay`. */
+    readonly hasBackdrop: boolean;
+    /** ARIA role for the content element. */
+    readonly role: AndesOverlayRole;
+    /** Whether the content element gets `aria-modal="true"`. */
+    readonly ariaModal: boolean;
+    /** Extra classes on the CDK overlay pane. */
+    readonly panelClass: string | readonly string[] | null;
+    /** Extra classes on the backdrop, in addition to `andes-overlay-backdrop`. */
+    readonly backdropClass: string | readonly string[] | null;
+    /** Re-position on scroll. Only meaningful for anchored positioning. */
+    readonly repositionOnScroll: boolean;
+    /** Dispose the overlay on browser back/forward. */
+    readonly disposeOnNavigation: boolean;
+    /** Explicit pane sizing. */
+    readonly size: AndesOverlaySize;
+}
+/**
+ * Deliberately conservative defaults: no focus trap, no scroll lock, no backdrop,
+ * no inert background. A consumer that forgets to configure gets the least
+ * invasive overlay rather than one that silently hijacks the page.
+ */
+declare const ANDES_OVERLAY_DEFAULT_CONFIG: AndesOverlayConfig;
+/** The overlay flavours the five planned components map onto. */
+type AndesOverlayPreset = 'dialog' | 'alert-dialog' | 'drawer' | 'popover' | 'menu' | 'tooltip';
+/**
+ * Starting points, not policy: every consumer is expected to spread a preset and
+ * then override. They exist so the five components do not each invent their own
+ * answer to "should a menu trap focus?" independently.
+ *
+ * - `dialog` / `alert-dialog` / `drawer` are modal: trap, lock scroll, backdrop,
+ *   and an inert background so AT cannot reach the page behind them.
+ *   `alert-dialog` additionally refuses outside-click dismissal, per the WAI-ARIA
+ *   distinction between `dialog` and `alertdialog`.
+ * - `drawer` sits on the `overlay` layer rather than `modal`, so a confirmation
+ *   dialog opened from inside a drawer stacks above it.
+ * - `popover` and `menu` move focus into the overlay (both are click-opened and
+ *   contain interactive content, so keyboard users must be able to reach it) but do
+ *   not trap it: the page behind stays usable and scrollable, as with any non-modal
+ *   popover, and they leave the rest of the page readable by
+ *   assistive tech. Consumers that render a close button inside and want modal
+ *   semantics can flip `trapFocus` and `inertBackground` on together.
+ * - `tooltip` moves nothing, traps nothing and restores nothing — it is a passive
+ *   hint attached to an element that already has focus.
+ */
+declare const ANDES_OVERLAY_PRESETS: Readonly<Record<AndesOverlayPreset, Partial<AndesOverlayConfig>>>;
+/** Reads a preset. A thin helper so consumers never hand-copy a preset's fields. */
+declare function andesOverlayPreset(preset: AndesOverlayPreset): Partial<AndesOverlayConfig>;
+/** What can be rendered into an overlay. */
+type AndesOverlayContent<C = unknown> = TemplateRef<C> | ComponentType<unknown>;
+/** Class applied to every andes-ng backdrop, as a styling hook for consumers. */
+declare const ANDES_OVERLAY_BACKDROP_CLASS = "andes-overlay-backdrop";
+/** Class applied to every andes-ng overlay pane, as a styling hook for consumers. */
+declare const ANDES_OVERLAY_PANE_CLASS = "andes-overlay-pane";
+/**
+ * Attribute (empty value) the overlay primitive sets while an overlay is closing,
+ * so a component can play an exit animation before the pane is removed.
+ *
+ * When `close()` is called, the attribute goes on the overlay pane, on each direct
+ * element child of the pane (the root elements of the component's own panel
+ * template, which is where emulated-encapsulation styles can reach it) and on the
+ * backdrop, if there is one. The pane and backdrop also stop receiving pointer
+ * events. The primitive then waits for every animation or transition running in
+ * the pane (and on the backdrop) to finish, at most
+ * {@link ANDES_OVERLAY_EXIT_TIMEOUT_MS}, before detaching.
+ *
+ * A component opts in by styling its panel root, for example
+ *
+ * ```css
+ * .panel[data-andes-closing] {
+ *   animation: panel-exit 120ms ease-in forwards;
+ * }
+ * @media (prefers-reduced-motion: reduce) {
+ *   .panel[data-andes-closing] { animation: none; }
+ * }
+ * ```
+ *
+ * Use `animation-fill-mode: forwards` (or a transition) so the panel does not
+ * snap back to full opacity between the end of the animation and the detach.
+ * Without any exit style the close stays instant and synchronous, and it is also
+ * instant when the user prefers reduced motion.
+ *
+ * While the attribute is present `isOpen()` is already `false`; focus is restored
+ * and `closed` emits only after the pane is detached. If focus moved to another
+ * element on the page during the exit, it stays there instead of returning to
+ * the trigger. Opening again before then
+ * removes the attribute and keeps the same pane, and neither `closed` nor `opened`
+ * emits for the interrupted close.
+ */
+declare const ANDES_OVERLAY_CLOSING_ATTRIBUTE = "data-andes-closing";
+/**
+ * Longest a close waits for exit animations before detaching the overlay anyway,
+ * so a stalled or endless animation can never keep a closed overlay on screen.
+ */
+declare const ANDES_OVERLAY_EXIT_TIMEOUT_MS = 300;
+
+/**
+ * Translates one andes-ng `side`/`align` pair into a CDK `ConnectedPosition`.
+ *
+ * `sideOffset` always pushes the overlay *away* from the anchor, so its sign
+ * depends on the side; `alignOffset` shifts along the perpendicular axis.
+ */
+declare function andesConnectedPosition(side: AndesOverlaySide, align: AndesOverlayAlign, sideOffset: number, alignOffset: number): ConnectedPosition;
+/**
+ * The preferred position first, then the fallbacks CDK walks when it does not fit:
+ * the opposite side (a flip), then - unless `crossSideFallback` is off - the two
+ * perpendicular sides (a last resort before CDK falls back to pushing the overlay into
+ * view).
+ */
+declare function andesConnectedPositions(side: AndesOverlaySide, align: AndesOverlayAlign, sideOffset: number, alignOffset: number, flip: boolean, crossSideFallback?: boolean): ConnectedPosition[];
+/**
+ * Builds the CDK position strategy for a config. Anchored positioning needs the
+ * anchor element; without one it degrades to centered rather than throwing, so a
+ * Popover whose trigger has not attached yet still renders somewhere sane.
+ */
+declare function createAndesPositionStrategy(injector: Injector, positioning: AndesOverlayPositioning, anchor: HTMLElement | null): PositionStrategy;
+/**
+ * Sizing implied by the positioning, before the consumer's explicit `size` wins.
+ * An edge-anchored panel spans the edge it is pinned to; nothing else implies a size.
+ */
+declare function andesImpliedSize(positioning: AndesOverlayPositioning): Pick<AndesOverlayConfig['size'], 'width' | 'height'>;
+
+/**
+ * Handle for one overlay's claim on an inert background. Releasing it undoes
+ * *that claim only*: elements another still-open overlay also depends on stay
+ * inert. Releasing twice is a no-op, so a double `close()` cannot under-count.
+ */
+interface AndesOverlayInertHandle {
+    release(): void;
+}
+/**
+ * Reference-counted registry of "everything outside the modal is inert".
+ *
+ * ## Why this exists
+ *
+ * A focus trap only governs Tab. A screen-reader user in browse mode (VoiceOver's
+ * `VO`-arrow, NVDA/JAWS virtual cursor) walks the accessibility tree directly and
+ * happily reads — and activates — content behind an open modal. `aria-modal="true"`
+ * on the dialog is a *hint* that browsers and AT do not universally honour on its
+ * own, which is why this primitive additionally marks the rest of the page inert.
+ *
+ * ## What gets marked
+ *
+ * Every **direct child of `<body>`** except the one containing the overlay itself.
+ * Not `<body>`, because the overlay's own portal is rendered into the CDK overlay
+ * container, which is itself a body child — inerting `<body>` would make the modal
+ * unusable. Also excluded: CDK's own accessibility infrastructure (`LiveAnnouncer`,
+ * `AriaDescriber`), which CDK likewise appends directly under `<body>` — see
+ * `NON_RENDERED_SELECTORS` below.
+ *
+ * ## Nesting
+ *
+ * Every andes-ng overlay portals into the *same* CDK overlay container, so a
+ * confirm dialog opened on top of a dialog needs the exact same background inert.
+ * Rather than re-applying (and then prematurely releasing) it, each open overlay
+ * takes a reference on the elements it needs; an element loses `inert` only when
+ * the last overlay holding it closes. Closing the inner dialog therefore leaves
+ * the outer dialog's background inert, and only the outermost close restores the
+ * page.
+ *
+ * Exempting the shared container is not enough on its own, though: it would leave
+ * the outer dialog — a sibling of the inner one inside that container — reachable
+ * behind it. So a modal also claims every *other* child of the overlay container
+ * (each earlier overlay's host wrapper and backdrop). Only what exists at open
+ * time is claimed, which is exactly what lies beneath the new modal: a popover or
+ * select opened later, from inside it, stays interactive. Those claims go through
+ * the same reference count, so closing the inner dialog hands the outer one back
+ * only once no other modal above it still holds it, in any closing order.
+ *
+ * ## What it refuses to touch
+ *
+ * An element that is *already* inert when we first see it is left alone entirely
+ * and never tracked: something outside our control put it there for its own
+ * reasons, and it is not ours to clear on close. Same for a pre-existing
+ * `aria-hidden`.
+ *
+ * Provided in root because the reference count is a property of the document, not
+ * of any one overlay instance — the same reason CDK's block-scroll strategy keeps
+ * its own global count.
+ */
+declare class AndesOverlayInertRegistry {
+    private readonly document;
+    private readonly entries;
+    /**
+     * The elements currently inert *because of us*. Elements that were already
+     * inert for their own reasons are deliberately absent. Exposed so a consumer
+     * (or a test) can assert on the primitive's footprint rather than on every
+     * `[inert]` element in the document.
+     */
+    get inertElements(): readonly Element[];
+    /**
+     * Marks every direct child of `<body>` inert, except the subtrees the given
+     * elements live in (the overlay's own pane and backdrop), plus every other
+     * overlay already open in the CDK overlay container — the layers beneath this
+     * one. Returns the handle that undoes exactly this claim.
+     */
+    inertBackgroundExcept(exemptElements: readonly (Element | null | undefined)[]): AndesOverlayInertHandle;
+    /**
+     * Takes a reference on one element. Returns whether the caller now holds one —
+     * `false` for an element that was already inert before we ever saw it, which we
+     * deliberately neither track nor modify.
+     */
+    private claim;
+    /** Drops one reference, clearing our attributes only when it was the last. */
+    private release;
+    private backgroundChildren;
+    /**
+     * The children of the CDK overlay container holding the exempt elements, other
+     * than the ones containing them: the host wrappers and backdrops of overlays
+     * opened earlier, and so stacked beneath this one.
+     */
+    private lowerOverlayLayers;
+    /**
+     * True for a body child that is itself an accessibility mechanism rather than
+     * page content — CDK's own (matched by class, since `NON_RENDERED_TAGS` only
+     * matches by tag), or a live region a consumer appended directly under `<body>`
+     * for the same reason CDK does: so it keeps announcing regardless of what else
+     * on the page is inert.
+     *
+     * `aria-live="off"` is excluded because it explicitly opts out of announcing —
+     * exempting it would serve no one and would needlessly leave an otherwise
+     * ordinary piece of background content out of the inert set.
+     */
+    private isAccessibilityInfrastructure;
+    /**
+     * Walks up from an element to the `<body>` child whose subtree contains it, so
+     * exempting an overlay pane exempts the whole portal outlet it was rendered into.
+     */
+    private bodyChildOf;
+    private supportsInert;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesOverlayInertRegistry, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AndesOverlayInertRegistry>;
+}
+
+/** Options accepted when opening an overlay. */
+interface AndesOverlayOpenOptions<C = unknown> {
+    /** Template context, for `TemplateRef` content. */
+    readonly context?: C;
+    /**
+     * View container used to instantiate `TemplateRef` content. Defaults to the one
+     * available where `AndesOverlayPrimitive` was provided, which is what a compound
+     * component wants; pass it explicitly only when opening a template that lives in
+     * some other view.
+     */
+    readonly viewContainerRef?: ViewContainerRef;
+    /** Injector for `ComponentType` content, so the component can inject the overlay. */
+    readonly injector?: Injector;
+    /**
+     * Element focus returns to on close, overriding the registered trigger.
+     */
+    readonly restoreFocusTo?: HTMLElement | ElementRef<HTMLElement> | null;
+}
+/**
+ * The shared overlay behavior primitive: portal rendering, positioning, focus
+ * management, dismissal and stacking for every andes-ng overlay component.
+ *
+ * It is a thin, tokens-integrated wrapper around Angular CDK's `Overlay` and
+ * `ConfigurableFocusTrap` rather than a reimplementation — the failure modes here
+ * (focus escaping a trap, focus returning to the wrong element, stacking-context
+ * bugs) are exactly the ones CDK already solves.
+ *
+ * ## Consuming it
+ *
+ * `AndesOverlayPrimitive` is deliberately *not* `providedIn: 'root'`. A compound
+ * component provides one instance for itself, and its own sub-directives inject it
+ * — Angular's equivalent of React context:
+ *
+ * ```ts
+ * @Component({
+ *   selector: 'andes-dialog',
+ *   providers: [provideAndesOverlay()],
+ *   template: `
+ *     <ng-content select="[andesOverlayTrigger]" />
+ *     <ng-template #content>
+ *       <div andesOverlayContent>
+ *         <h2 id="title">Delete project</h2>
+ *         <button andesOverlayClose>Cancel</button>
+ *       </div>
+ *     </ng-template>
+ *   `,
+ * })
+ * export class AndesDialog {
+ *   private readonly overlay = inject(AndesOverlayPrimitive);
+ *   private readonly content = viewChild.required<TemplateRef<unknown>>('content');
+ *
+ *   constructor() {
+ *     this.overlay.configure(andesOverlayPreset('dialog'));
+ *   }
+ *
+ *   open() {
+ *     this.overlay.open(this.content());
+ *   }
+ * }
+ * ```
+ *
+ * ## Stacking
+ *
+ * Overlays are rendered inside CDK's overlay container (never as a native
+ * `popover`, which would move them to the top layer where `z-index` is ignored and
+ * ordering is by call time). `z-index` comes from `--andes-z-index-*` per layer, so
+ * a Popover opened from inside a Dialog stacks above it without either component
+ * hard-coding a number.
+ *
+ * ## Modality
+ *
+ * A modal overlay needs three separate things, and `aria-modal` is only the weakest
+ * of them: `trapFocus` for Tab, `ariaModal` as a hint, and `inertBackground` to
+ * actually mark every other body child `inert` so a screen reader's browse mode
+ * cannot walk into the page behind it. The modal presets turn on all three.
+ *
+ * ## Exit animations
+ *
+ * `close()` does not always detach at once. It sets
+ * {@link ANDES_OVERLAY_CLOSING_ATTRIBUTE} on the pane, its direct element children
+ * and the backdrop, and detaches once the animations that starts have finished
+ * (capped at {@link ANDES_OVERLAY_EXIT_TIMEOUT_MS}). With no exit animation, with
+ * reduced motion, or where the browser cannot report animations, the close is
+ * synchronous. `isOpen()` turns `false` immediately either way.
+ */
+declare class AndesOverlayPrimitive {
+    private readonly injector;
+    private readonly document;
+    private readonly focusTrapFactory;
+    private readonly inertRegistry;
+    private readonly hostViewContainerRef;
+    private readonly _config;
+    private readonly _isOpen;
+    private readonly _anchor;
+    private readonly _panelElement;
+    private readonly _backdropElement;
+    private readonly _contentElement;
+    private readonly _isBackgroundInert;
+    /** The resolved behavior configuration. */
+    readonly config: _angular_core.Signal<AndesOverlayConfig>;
+    /**
+     * Whether the overlay is open. Turns `false` as soon as a close is requested,
+     * even while the pane is still attached playing its exit animation.
+     */
+    readonly isOpen: _angular_core.Signal<boolean>;
+    /** The registered trigger element, if any. */
+    readonly anchor: _angular_core.Signal<HTMLElement | null>;
+    /** The CDK overlay pane, while attached (including during its exit animation). */
+    readonly panelElement: _angular_core.Signal<HTMLElement | null>;
+    /** The backdrop scrim, while open and if the config renders one. */
+    readonly backdropElement: _angular_core.Signal<HTMLElement | null>;
+    /** The element carrying `andesOverlayContent`, while open. */
+    readonly contentElement: _angular_core.Signal<HTMLElement | null>;
+    /**
+     * Whether this overlay currently holds the page's background inert. False for a
+     * non-modal overlay, and false again as soon as it closes — even if an outer
+     * overlay still keeps the background inert for its own sake.
+     */
+    readonly isBackgroundInert: _angular_core.Signal<boolean>;
+    /**
+     * Stable id shared by the trigger's `aria-controls`/`aria-describedby` and the
+     * content element's `id`, so assistive tech can relate the two.
+     */
+    readonly contentId: string;
+    private readonly _opened;
+    private readonly _closed;
+    private readonly _keydown;
+    private readonly _outsidePointer;
+    /** Emits after the overlay has been attached. */
+    readonly opened: Observable<void>;
+    /**
+     * Emits the reason after the overlay has been detached — after its exit
+     * animation, if it has one. Not emitted for a close cancelled by re-opening.
+     */
+    readonly closed: Observable<AndesOverlayCloseReason>;
+    /**
+     * Keydown events reaching the open overlay. Only the topmost overlay receives
+     * them. Dropdown Menu builds its arrow-key/typeahead navigation on this.
+     */
+    readonly keydownEvents: Observable<KeyboardEvent>;
+    /** Pointer events outside the open overlay, whether or not they close it. */
+    readonly outsidePointerEvents: Observable<MouseEvent>;
+    private overlayRef;
+    private focusTrap;
+    private inertHandle;
+    private focusOrigin;
+    private explicitRestoreTarget;
+    private openSubscriptions;
+    private pendingExit;
+    private attachedContent;
+    private attachedContext;
+    constructor();
+    /**
+     * Merges a partial configuration in. Intended to be called from a consuming
+     * component's constructor with a preset, then again from an `effect` as its own
+     * inputs change.
+     *
+     * While the overlay is open, `positioning`, `size` and `layer` are re-applied
+     * immediately. The structural flags (`hasBackdrop`, `trapFocus`, `lockScroll`,
+     * `inertBackground`, `autoFocus`) take effect on the next `open()`; the
+     * dismissal flags (`closeOnEscape`, `closeOnOutsideClick`) are read at event
+     * time and so apply immediately.
+     */
+    configure(patch: Partial<AndesOverlayConfig>): void;
+    /**
+     * Registers the element anchored positioning measures against, and the element
+     * focus returns to on close. `AndesOverlayTriggerPrimitive` calls this for you.
+     */
+    registerAnchor(element: HTMLElement | ElementRef<HTMLElement> | null | undefined): void;
+    /** Registers the content element. `AndesOverlayContentPrimitive` calls this. */
+    registerContent(element: HTMLElement | ElementRef<HTMLElement> | null | undefined): void;
+    /**
+     * Opens the overlay with the given content. A no-op if already open.
+     *
+     * Called while the overlay is still playing its exit animation with the same
+     * content and context, it cancels the close and keeps the same pane, so the
+     * panel does not flicker; with different content the old pane is detached first.
+     */
+    open<C>(content: AndesOverlayContent<C>, options?: AndesOverlayOpenOptions<C>): void;
+    /**
+     * Closes the overlay. A no-op if already closed or closing.
+     *
+     * `isOpen()` turns `false` at once. If the closing attribute starts an exit
+     * animation, the pane stays attached until it ends; focus restoration and the
+     * `closed` emission follow the detach.
+     */
+    close(reason?: AndesOverlayCloseReason): void;
+    /** Opens the overlay if closed, closes it if open. */
+    toggle<C>(content: AndesOverlayContent<C>, options?: AndesOverlayOpenOptions<C>): void;
+    /** Recomputes the overlay's position. Cheap to call on resize or content change. */
+    updatePosition(): void;
+    /**
+     * Moves focus to the first tabbable element inside the overlay. Exposed for
+     * consumers that focus lazily — a Dropdown Menu opened by keyboard, say.
+     */
+    focusFirstTabbable(): void;
+    private beginClose;
+    /**
+     * Marks the pane, its direct element children and the backdrop as closing and
+     * returns the animations that marking started. Nothing is marked when the exit
+     * would be skipped anyway: reduced motion, or no `getAnimations` (SSR, jsdom).
+     */
+    private startExit;
+    /** Re-opening during the exit: undo the close on the pane that is still there. */
+    private cancelExit;
+    /** Detaches the overlay and finishes a requested close. */
+    private completeClose;
+    /**
+     * Whether focus now sits on a page element outside the pane. Focus inside the
+     * pane (an Escape or close-button close) or dropped on `body` still restores.
+     */
+    private focusMovedOutside;
+    private prefersReducedMotion;
+    private buildOverlayConfig;
+    private anchorWidth;
+    private buildScrollStrategy;
+    private applyLayerStyles;
+    private styleBackdrop;
+    private wireDismissal;
+    /**
+     * Makes the page outside the overlay inert, so AT browsing the document — not
+     * just tabbing through it — cannot reach content behind a modal. That includes
+     * overlays already open beneath it in the same CDK container (an outer dialog).
+     * The pane and backdrop are exempt, and the registry reference-counts across
+     * nested overlays.
+     */
+    private applyInertBackground;
+    private releaseInertBackground;
+    private installFocusManagement;
+    /**
+     * Focus goes back to, in order: an explicit `restoreFocusTo`, the registered
+     * trigger, the element that was focused when the overlay opened. Each candidate
+     * is skipped if it is no longer in the document — a trigger inside a list row
+     * that the overlay's own action deleted, say. If none survive, focus is left to
+     * the browser's own fallback (`document.body`).
+     */
+    private restoreFocus;
+    private activeElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesOverlayPrimitive, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AndesOverlayPrimitive>;
+}
+/**
+ * Providers a compound overlay component puts in its own `providers` array to own
+ * one overlay instance, scoped to itself and injectable by its sub-directives.
+ */
+declare function provideAndesOverlay(): Provider[];
+
+/**
+ * How a trigger advertises its overlay to assistive tech.
+ *
+ * - `expanded` — `aria-haspopup` + `aria-expanded` + `aria-controls`. Correct for
+ *   Dialog, Drawer, Popover and Dropdown Menu, where the trigger opens something
+ *   the user then interacts with.
+ * - `described-by` — `aria-describedby` pointing at the overlay. Correct for
+ *   Tooltip: the overlay describes the trigger, it is not a thing you open.
+ * - `none` — the consumer wires its own ARIA.
+ */
+type AndesOverlayAriaAttachment = 'expanded' | 'described-by' | 'none';
+/**
+ * Marks an element as an overlay's trigger. Registers it as the positioning anchor
+ * and as the element focus returns to on close, and keeps its ARIA state in sync.
+ *
+ * It intentionally does *not* bind a click handler: whether the overlay opens on
+ * click, hover, focus or context menu is the consuming component's decision (and
+ * differs across Dialog, Popover, Tooltip and Dropdown Menu). Call
+ * `trigger.overlay.toggle(template)` from wherever that decision is made.
+ */
+declare class AndesOverlayTriggerPrimitive {
+    /** The overlay this trigger belongs to. */
+    readonly overlay: AndesOverlayPrimitive;
+    private readonly elementRef;
+    /** Which ARIA relationship to expose. Defaults to `expanded`. */
+    readonly ariaAttachment: _angular_core.InputSignal<AndesOverlayAriaAttachment>;
+    protected readonly ariaHasPopup: _angular_core.Signal<"listbox" | "dialog" | "menu" | undefined>;
+    protected readonly ariaExpanded: _angular_core.Signal<string | undefined>;
+    protected readonly ariaControls: _angular_core.Signal<string | undefined>;
+    protected readonly ariaDescribedBy: _angular_core.Signal<string | undefined>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesOverlayTriggerPrimitive, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AndesOverlayTriggerPrimitive, "[andesOverlayTrigger]", ["andesOverlayTrigger"], { "ariaAttachment": { "alias": "ariaAttachment"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Marks the root element of an overlay's projected content. Applies the ARIA role
+ * and the id the trigger points at, and reports the element back to the primitive
+ * so consumers can measure or query it.
+ *
+ * The focus trap brackets the CDK pane rather than this element, so content can
+ * safely render siblings (an arrow, a swipe handle) outside it.
+ */
+declare class AndesOverlayContentPrimitive {
+    /** The overlay this content belongs to. */
+    readonly overlay: AndesOverlayPrimitive;
+    private readonly elementRef;
+    protected readonly role: _angular_core.Signal<"listbox" | "tooltip" | "dialog" | "alertdialog" | "menu" | undefined>;
+    protected readonly ariaModal: _angular_core.Signal<"true" | undefined>;
+    protected readonly tabIndex: _angular_core.Signal<"-1" | undefined>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesOverlayContentPrimitive, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AndesOverlayContentPrimitive, "[andesOverlayContent]", ["andesOverlayContent"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Closes the overlay when activated. Every modal overlay should render one of
+ * these inside its content: Escape and outside-click are not reachable for touch
+ * screen-reader users, so an in-content dismiss affordance is an accessibility
+ * requirement, not a convenience.
+ */
+declare class AndesOverlayClosePrimitive {
+    /** The overlay this control closes. */
+    readonly overlay: AndesOverlayPrimitive;
+    protected close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesOverlayClosePrimitive, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AndesOverlayClosePrimitive, "[andesOverlayClose]", ["andesOverlayClose"], {}, {}, never, never, true, never>;
+}
+
+/** The CDK's own typeahead debounce default, restated so consumers can reference it. */
+declare const ANDES_LIST_TYPEAHEAD_DEBOUNCE = 200;
+/**
+ * Shared list-navigation state for a listbox, menu, tablist or combobox popup: roving
+ * tabindex or `aria-activedescendant` focus management, arrow-key navigation in either
+ * orientation, `Home`/`End`, typeahead and disabled-item skipping.
+ *
+ * This is a thin, signal-shaped wrapper around Angular CDK's own `ListKeyManager` family
+ * (`FocusKeyManager` for `roving-tabindex`, `ActiveDescendantKeyManager` for
+ * `active-descendant`) — the key handling, typeahead buffering and wrap-around arithmetic
+ * are the CDK's, not a reimplementation.
+ *
+ * It is a DI-scoped service, not a directive: provide it from the consuming component so
+ * that every descendant item — including items rendered into a CDK overlay, which are
+ * injector descendants but not DOM descendants — can inject the same instance.
+ *
+ * ```ts
+ * @Component({
+ *   selector: 'andes-tabs',
+ *   providers: [AndesListNavigation],
+ *   template: `
+ *     <div role="tablist" andesListNavigationKeys>
+ *       @for (tab of tabs(); track tab.value) {
+ *         <button role="tab" type="button" andesListNavigationItem [disabled]="tab.disabled">
+ *           {{ tab.label }}
+ *         </button>
+ *       }
+ *     </div>
+ *   `,
+ * })
+ * export class AndesTabs {
+ *   protected readonly navigation = inject(AndesListNavigation);
+ *
+ *   constructor() {
+ *     this.navigation.configure({ orientation: 'horizontal', wrap: true });
+ *   }
+ * }
+ * ```
+ *
+ * What this primitive deliberately does *not* do: it owns no selection state, sets no
+ * `role`/`aria-selected`/`aria-checked`, and never interprets `Enter`, `Space` or `Escape`.
+ * "Active item" is focus, not selection — a component that activates on focus (Tabs in
+ * automatic-activation mode) reacts to {@link activeItem} in an `effect`, while one that
+ * activates manually handles `Enter`/`Space` itself.
+ */
+declare class AndesListNavigation {
+    private readonly injector;
+    private readonly destroyRef;
+    /** Which arrow keys navigate. */
+    readonly orientation: _angular_core.WritableSignal<AndesListOrientation>;
+    /** Whether navigation wraps around the ends of the list. */
+    readonly wrap: _angular_core.WritableSignal<boolean>;
+    /** Whether typing characters moves the active item. */
+    readonly typeahead: _angular_core.WritableSignal<boolean>;
+    /** How long to wait after the last keystroke before matching. */
+    readonly typeaheadDebounce: _angular_core.WritableSignal<number>;
+    /** Whether `Home`/`End` jump to the first/last enabled item. */
+    readonly homeAndEnd: _angular_core.WritableSignal<boolean>;
+    /** How the active item is surfaced to assistive technology. */
+    readonly focusMode: _angular_core.WritableSignal<AndesListFocusMode>;
+    /** Text direction used to mirror horizontal arrow keys. */
+    readonly textDirection: _angular_core.WritableSignal<AndesListTextDirection>;
+    /** Whether disabled items are skipped while navigating. */
+    readonly skipDisabled: _angular_core.WritableSignal<boolean>;
+    private readonly _items;
+    /** Every registered item, in DOM order. */
+    readonly items: Signal<readonly AndesListNavigationItemRef[]>;
+    private readonly _activeItem;
+    /** The active item, or `null` when nothing is active yet. */
+    readonly activeItem: Signal<AndesListNavigationItemRef | null>;
+    private readonly _activeIndex;
+    /** Index of the active item within {@link items}, or `-1` when nothing is active. */
+    readonly activeIndex: Signal<number>;
+    /**
+     * The `id` to publish as `aria-activedescendant`, or `null` in `roving-tabindex` mode
+     * (where real focus already conveys the active item).
+     */
+    readonly activeDescendantId: Signal<string | null>;
+    /**
+     * The single item that should carry `tabindex="0"` in `roving-tabindex` mode: the active
+     * item, or — before anything is active — the first item the user can navigate to, so the
+     * list is always reachable with one Tab press.
+     */
+    readonly rovingTabindexTarget: Signal<AndesListNavigationItemRef | null>;
+    private readonly _tabOut;
+    /** Emits when `Tab` is pressed, so a menu or popup can close and hand focus back. */
+    readonly tabOut: Observable<void>;
+    private keyManager;
+    private keyManagerMode;
+    private appliedTypeaheadDebounce;
+    private destroyed;
+    constructor();
+    /** Applies any subset of the configuration options in one call. */
+    configure(config: AndesListNavigationConfig): void;
+    /** Adds an item to the list. Called by {@link AndesListNavigationItem} on init. */
+    register(item: AndesListNavigationItemRef): void;
+    /**
+     * Removes an item from the list. Called by {@link AndesListNavigationItem} on destroy.
+     * Removing the active item clears the active state rather than guessing a neighbour.
+     */
+    unregister(item: AndesListNavigationItemRef): void;
+    /**
+     * Handles a `keydown` on whichever element owns keyboard focus for this list — the
+     * tablist/menu in `roving-tabindex` mode, the text input in `active-descendant` mode.
+     * {@link AndesListNavigationKeys} wires this up for you.
+     *
+     * Only navigation keys are consumed (and `preventDefault`ed); `Enter`, `Space` and
+     * `Escape` are left entirely to the consumer.
+     *
+     * Note: this delegates to the CDK, which reads the (deprecated but universally
+     * populated) `KeyboardEvent.keyCode`. Real browsers always set it; synthetic events in
+     * unit tests must set it explicitly.
+     */
+    onKeydown(event: KeyboardEvent): void;
+    /** Moves the active item to the first enabled item. */
+    focusFirst(): void;
+    /** Moves the active item to the last enabled item. */
+    focusLast(): void;
+    /** Moves the active item forwards, respecting {@link wrap} and {@link skipDisabled}. */
+    focusNext(): void;
+    /** Moves the active item backwards, respecting {@link wrap} and {@link skipDisabled}. */
+    focusPrevious(): void;
+    /** Makes a specific item active, applying the current focus mode's effects. */
+    focusItem(item: AndesListNavigationItemRef | number): void;
+    /**
+     * Moves the active pointer without focusing the item — for restoring an active item
+     * after the list is re-filtered, or for following a click/`focusin` that already moved
+     * real focus. Being silent, it also skips scrolling the item into view; use
+     * {@link focusItem} when the item should be revealed.
+     */
+    setActiveItemSilently(item: AndesListNavigationItemRef | number | null): void;
+    /** Clears the active item, e.g. when a popup closes. */
+    clearActive(): void;
+    /** Whether a typeahead query is currently buffered. */
+    isTyping(): boolean;
+    /** Discards any buffered typeahead query. */
+    cancelTypeahead(): void;
+    private shouldSkip;
+    /**
+     * Returns the CDK key manager for the current focus mode, creating it on first use and
+     * rebuilding it (carrying the active item over) if the focus mode changes.
+     */
+    private resolveKeyManager;
+    private applyConfig;
+    private syncActive;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesListNavigation, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AndesListNavigation>;
+}
+
+/**
+ * One navigable item inside a list governed by {@link AndesListNavigation}: an option, a
+ * menu item or a tab. Registers itself with the parent on init and removes itself on
+ * destroy, so `@if`/`@for`-driven lists and CDK-overlay popups work without any manual
+ * bookkeeping.
+ *
+ * It manages only the mechanics of being navigable — the roving `tabindex`, a stable `id`
+ * for `aria-activedescendant`, and `data-active`/`data-disabled` hooks for styling. Roles
+ * and selection attributes (`role="option"`, `aria-selected`, `aria-checked`) stay with the
+ * consuming component.
+ *
+ * ```html
+ * <button type="button" andesListNavigationItem [disabled]="option.disabled">
+ *   {{ option.label }}
+ * </button>
+ * ```
+ */
+declare class AndesListNavigationItem implements AndesListNavigationItemRef, OnInit, OnDestroy {
+    /** Whether the item is skipped while navigating. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Text typeahead matches against. Defaults to the item's own text content, which is
+     * usually right; set it when the visible text is decorative or split across elements.
+     */
+    readonly typeaheadLabel: _angular_core.InputSignal<string | undefined>;
+    /** @internal Mirrors {@link disabled} under the name the parent's item contract uses. */
+    readonly isDisabled: Signal<boolean>;
+    private readonly navigation;
+    readonly element: HTMLElement;
+    /** The item's DOM `id` — its own, when it has one, so authored ids are never clobbered. */
+    readonly itemId: string;
+    /** Whether this is the parent's active item. */
+    readonly active: Signal<boolean>;
+    /**
+     * `0` on the one roving-tabindex target, `-1` on every other item, and absent entirely in
+     * `active-descendant` mode, where items are not focusable at all.
+     */
+    protected readonly tabIndex: Signal<number | null>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getLabel(): string;
+    focus(): void;
+    /**
+     * The CDK's `Highlightable` hook, called only in `active-descendant` mode. Andes derives
+     * the active *styling* from the parent's signal instead (see {@link active}), so that it
+     * works identically in both focus modes; what is genuinely mode-specific is scrolling —
+     * real focus never moves here, so the item has to bring itself into view.
+     */
+    setActiveStyles(): void;
+    /**
+     * Counterpart to {@link setActiveStyles}. Nothing to undo: the active styling is derived
+     * from the parent's signal, and scrolling is not reversible.
+     */
+    setInactiveStyles(): void;
+    /**
+     * Keeps the roving `tabindex` on whichever item the user actually reached, including via
+     * mouse or a direct Tab, so Tabbing away and back returns to the same place.
+     */
+    protected onFocusin(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesListNavigationItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AndesListNavigationItem, "[andesListNavigationItem]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "typeaheadLabel": { "alias": "typeaheadLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Wires the keyboard-owning element of a list to its {@link AndesListNavigation}: forwards
+ * `keydown` to the key manager and publishes `aria-activedescendant` when the list is in
+ * `active-descendant` mode.
+ *
+ * Put it on whichever element holds real DOM focus:
+ *
+ * - Tabs — the `role="tablist"` element.
+ * - Dropdown Menu — the `role="menu"` popup.
+ * - Select — the trigger while closed, or the `role="listbox"` popup once focus moves into it.
+ * - Combobox — the `<input>` itself, which keeps focus the whole time.
+ *
+ * It only consumes navigation keys, so the consumer is free to bind its own `keydown`
+ * handler on the same element for `Enter`, `Space` and `Escape`.
+ *
+ * ```html
+ * <input andesListNavigationKeys role="combobox" (keydown.enter)="commit()" />
+ * ```
+ */
+declare class AndesListNavigationKeys {
+    protected readonly navigation: AndesListNavigation;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndesListNavigationKeys, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AndesListNavigationKeys, "[andesListNavigationKeys]", never, {}, {}, never, never, true, never>;
+}
+
+export { ANDES_BREAKPOINTS, ANDES_BREAKPOINT_NAMES, ANDES_BREAKPOINT_SSR_DEFAULT, ANDES_CHOICE_ROLE_MAPPINGS, ANDES_LIST_TYPEAHEAD_DEBOUNCE, ANDES_OVERLAY_BACKDROP_CLASS, ANDES_OVERLAY_CLOSING_ATTRIBUTE, ANDES_OVERLAY_DEFAULT_CONFIG, ANDES_OVERLAY_EXIT_TIMEOUT_MS, ANDES_OVERLAY_PANE_CLASS, ANDES_OVERLAY_PRESETS, ANDES_OVERLAY_SCRIM, ANDES_OVERLAY_Z_INDEX_FALLBACKS, ANDES_TREE_TYPEAHEAD_DEBOUNCE, AndesBreakpoints, AndesButtonPrimitive, AndesCheckedTree, AndesChoiceGroup, AndesChoiceItem, AndesFormControlBase, AndesListNavigation, AndesListNavigationItem, AndesListNavigationKeys, AndesOverlayClosePrimitive, AndesOverlayContentPrimitive, AndesOverlayInertRegistry, AndesOverlayPrimitive, AndesOverlayTriggerPrimitive, AndesResizeObserver, AndesSelectionModel, AndesTreeNavigation, AndesTreeNavigationItem, AndesTreeNavigationKeys, AndesValueAccessor, andesBreakpointForWidth, andesConnectedPosition, andesConnectedPositions, andesContainerBreakpoint, andesElementSize, andesImpliedSize, andesMediaQuery, andesOverlayPreset, andesOverlayZIndex, andesPrefersContrast, andesPrefersDark, andesPrefersReducedMotion, andesShallowArrayEquals, createAndesPositionStrategy, injectAndesControlStatus, provideAndesOverlay, provideAndesValueAccessor };
+export type { AndesBreakpoint, AndesCheckState, AndesCheckedStrategy, AndesCheckedTreeConfig, AndesChoiceDataState, AndesChoiceGroupRole, AndesChoiceItemRef, AndesChoiceItemRole, AndesChoiceMode, AndesChoiceRoleMapping, AndesChoiceStateAttribute, AndesChoiceValue, AndesContainerBreakpointOptions, AndesControlStatus, AndesControlStatusOptions, AndesElementBox, AndesElementMeasure, AndesElementSizeOptions, AndesElementSizeRef, AndesElementSizeTarget, AndesListFocusMode, AndesListNavigationConfig, AndesListNavigationItemRef, AndesListOrientation, AndesListTextDirection, AndesMediaQueryOptions, AndesOverlayAlign, AndesOverlayAnchoredPositioning, AndesOverlayAriaAttachment, AndesOverlayAutoFocus, AndesOverlayCenteredPositioning, AndesOverlayCloseReason, AndesOverlayConfig, AndesOverlayContent, AndesOverlayEdge, AndesOverlayEdgePositioning, AndesOverlayInertHandle, AndesOverlayLayer, AndesOverlayOpenOptions, AndesOverlayPositioning, AndesOverlayPreset, AndesOverlayRole, AndesOverlaySide, AndesOverlaySize, AndesResizeObserveOptions, AndesSelectionChange, AndesSelectionChangeSource, AndesSelectionMode, AndesSelectionModelConfig, AndesSelectionState, AndesTreeFocusMode, AndesTreeNavigationConfig, AndesTreeNavigationExpandChange, AndesTreeNavigationExpandedSource, AndesTreeNavigationItemRef, AndesTreeNavigationKey, AndesTreeNavigationNode, AndesTreeNavigationNodeInfo, AndesTreeNavigationNodeSource, AndesTreeNavigationRevealRequest, AndesTreeNavigationScope, AndesTreeOrientation, AndesTreeTextDirection, AndesValueAccessorOptions };