@duyluonganduin/acl-web-components 0.0.70 → 0.0.71

package/dist/react.d.ts

@@ -1,4 +1,5 @@
 import { CSSResult } from 'lit';
+import { CSSResultGroup } from 'lit';
 import { EventName } from '@lit/react';
 import { LitElement } from 'lit';
 import { nothing } from 'lit';
@@ -61,17 +62,196 @@ declare class AnduinAiSpinner extends LitElement {
     private dropPhaseClasses;
 }
 
+/**
+ * `<anduin-autocomplete>` — the design repo's free-text field with suggestions. The value is
+ * whatever the field holds; picking a suggestion writes its label into the field. Unlike
+ * `anduin-combobox` the text is never reverted when the list closes.
+ *
+ * ```html
+ * <anduin-autocomplete>
+ *   <anduin-autocomplete-input placeholder="Search funds..."></anduin-autocomplete-input>
+ *   <anduin-autocomplete-content>
+ *     <anduin-autocomplete-empty>No matching funds</anduin-autocomplete-empty>
+ *     <anduin-autocomplete-list>
+ *       <anduin-autocomplete-item value="nw-x">Northwind Real Estate Partners X</anduin-autocomplete-item>
+ *     </anduin-autocomplete-list>
+ *   </anduin-autocomplete-content>
+ * </anduin-autocomplete>
+ * ```
+ *
+ * `value` follows the text (written back on every keystroke); a value set from outside updates
+ * the field and re-filters without firing `change`, so a controlled binding cannot loop.
+ */
+declare class AnduinAutocomplete extends PickerRoot {
+    static family: string;
+    private _current;
+    firstUpdated(): void;
+    updated(changed: PropertyValues<this>): void;
+    /** The text in the field. */
+    get text(): string;
+    private _syncText;
+    /** Records new text and reports it as `change`. */
+    private _commit;
+    protected openQuery(): string;
+    protected emptyVisible(_query: string, nothingMatched: boolean): boolean;
+    /** With nothing to suggest and no empty element, the panel hides itself rather than show an empty box. */
+    protected panelVisible(nothingMatched: boolean): boolean;
+    protected onClosed(): void;
+    protected onItemChosen(value: string): void;
+    /** Commits a suggestion: its label becomes the text, `on-choose` fires with its value, the list closes. */
+    choose(value: string): void;
+    get hasHighlight(): boolean;
+    /** Enter on the highlighted suggestion. */
+    chooseHighlighted(): void;
+    /** Empties the field (the ✕, or Escape on a closed single-row field) and hands focus back to it. */
+    clear(): void;
+    fieldFocus(): void;
+    fieldInput(text: string): void;
+}
+
+/** `<anduin-autocomplete-clear>` — slotted in a field: a ✕ shown only while there is text; clears it and refocuses. */
+declare class AnduinAutocompleteClear extends LitElement {
+    static styles: CSSResult;
+    hasText: boolean;
+    connectedCallback(): void;
+    private _onClick;
+    render(): TemplateResult<1>;
+}
+
+/** `<anduin-autocomplete-content>` — the floating panel. `width` (px) pins its width; otherwise it shrink-wraps (min 160px). */
+declare class AnduinAutocompleteContent extends PickerContent {
+    static family: string;
+}
+
+/** `<anduin-autocomplete-empty>` — shown when the text matches nothing. Without one, the panel hides instead. */
+declare class AnduinAutocompleteEmpty extends PickerEmpty {
+    static family: string;
+}
+
+/** `<anduin-autocomplete-group>` — a labelled section; hides itself when every suggestion in it is filtered out. */
+declare class AnduinAutocompleteGroup extends PickerGroup {
+    static family: string;
+}
+
+/**
+ * `<anduin-autocomplete-input>` — the single-row field. Attributes: `placeholder`, `size`
+ * (`small` 24px / `default` 32px / `large` 40px), `status`, `disabled="true"`, `open-on-focus`,
+ * `label`. JS property `filter`. Slot an `<anduin-autocomplete-clear>` for a ✕.
+ */
+declare class AnduinAutocompleteInput extends AutocompleteFieldBase {
+    static styles: CSSResult[];
+    private _onKeyDown;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * `<anduin-autocomplete-item value="…">Label</anduin-autocomplete-item>` — a suggestion. `label`
+ * overrides the text committed and filtered on; `start-icon` adds a leading icon; `disabled`
+ * keeps it visible but unpickable.
+ */
+declare class AnduinAutocompleteItem extends PickerItem {
+    static family: string;
+    static styles: CSSResultGroup[];
+    startIcon: string;
+    protected renderStart(): TemplateResult<1> | typeof nothing;
+}
+
+/** `<anduin-autocomplete-label>` — a group's heading. */
+declare class AnduinAutocompleteLabel extends PickerLabel {
+    static family: string;
+}
+
+/** `<anduin-autocomplete-list>` — the listbox. `max-height` caps it (any CSS length); `items` (JS) renders data. */
+declare class AnduinAutocompleteList extends PickerList {
+    static family: string;
+}
+
+/** `<anduin-autocomplete-separator>` — a divider; hides when left dangling by the filter. */
+declare class AnduinAutocompleteSeparator extends PickerSeparator {
+    static family: string;
+}
+
+/**
+ * `<anduin-autocomplete-textarea>` — the multi-row field. Same API as the input plus `rows`
+ * (default 3) and `max-rows` (default 6): it grows a line at a time between them, then scrolls.
+ * Enter commits a highlighted suggestion; otherwise it reports `on-submit` and, unless that is
+ * cancelled, inserts a newline. Shift+Enter is always a newline.
+ */
+declare class AnduinAutocompleteTextarea extends AutocompleteFieldBase {
+    static styles: CSSResult[];
+    rows: number;
+    maxRows: number;
+    updated(changed: PropertyValues<this>): void;
+    /** Grows the field between `rows` and `max-rows` lines; past that it scrolls. */
+    private _grow;
+    protected _onInput(e: Event): void;
+    set text(value: string);
+    get text(): string;
+    private _onKeyDown;
+    render(): TemplateResult<1>;
+}
+
 declare class AnduinAvatar extends LitElement {
     static styles: CSSResult;
     src: string;
     name: string;
     alt: string;
     icon: string;
-    size: AvatarSize;
+    /** 16 | 20 | 24 | 32 | 40, or the design repo's 'small' | 'medium' | 'large' | 'extraLarge'. */
+    size: AvatarSize | DesignAvatarSize;
     shape: AvatarShape;
+    /**
+     * Design-repo API. Setting `uid` (even to `""`) or `value` switches the avatar to the design repo's behaviour:
+     * initials from `value`, a deterministic colour from `uid`, `uid="anduin"` for the Anduin logo, and an empty
+     * `uid` for an inactive avatar that shows its slotted content. `name` / `src` / `icon` keep their old behaviour.
+     */
+    uid: string | null;
+    value: string | null;
+    /** Accessible name (design API); replaces `value` as what the avatar is read as. */
+    label: string;
     private _imgError;
     private _onImgError;
+    /** The size in pixels, for either API. */
+    private get _px();
+    /** The design repo's named size, for either API. */
+    private get _designSize();
+    /** Whether the design repo's `uid` / `value` API is in use. */
+    get isDesignMode(): boolean;
     private _iconSize;
+    private _renderDesign;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * `<anduin-avatar-block>` — the design repo's avatar + name + email block.
+ *
+ * The avatar (an `anduin-avatar` in the design `uid` / `value` mode, `aria-hidden` because the name is written
+ * beside it) sits on the left; the name (`value`) on top and the email below with a copy-to-clipboard button. Both
+ * text rows truncate with an ellipsis when the block is narrower than its content (give it `display: block` or a
+ * width to constrain it).
+ *
+ * Slots: `value` replaces the name row (the `value` attribute still drives the initials); `email` replaces the
+ * whole email row, including the copy button.
+ */
+declare class AnduinAvatarBlock extends LitElement {
+    static styles: CSSResult;
+    /** Drives the avatar colour. Empty: an inactive (gray) avatar; `"anduin"`: the Anduin logo. */
+    uid: string;
+    /** Full name: the displayed name and the source of the avatar initials. */
+    value: string;
+    /** Email shown under the name with a copy button. Empty: no email row. */
+    email: string;
+    /** Avatar shape: 'circle' (default) | 'square'. */
+    shape: 'circle' | 'square' | '';
+    /** Avatar size: 'small' | 'medium' | 'large' (default) | 'extraLarge'. */
+    size: 'small' | 'medium' | 'large' | 'extraLarge' | '';
+    private _copyStatus;
+    private _announcement;
+    private _resetTimer;
+    disconnectedCallback(): void;
+    /** Copies the email as the built-in copy button does. Resolves with whether the write succeeded. */
+    copyEmail(): Promise<boolean>;
+    private _renderEmail;
     render(): TemplateResult<1>;
 }
 
@@ -203,6 +383,273 @@ declare class AnduinCheckbox extends LitElement {
     render(): TemplateResult<1>;
 }
 
+/**
+ * `<anduin-clipboard>` — copies `value` to the clipboard when its
+ * `<anduin-clipboard-trigger>` (or `<anduin-clipboard-indicator>`) is clicked.
+ *
+ * The status goes to `copied` at once, to `failed` if the browser refuses the
+ * write, and back to `idle` 2 seconds after the request. A polite live region
+ * announces the outcome ("Invoice number copied to clipboard").
+ */
+declare class AnduinClipboard extends LitElement {
+    static styles: CSSResult;
+    /** The text to copy, read at click time. */
+    value: string;
+    /** What the value is ("Invoice number"): names an icon-only trigger and the announcement. */
+    label: string;
+    private _status;
+    private _announcement;
+    private _resetTimer;
+    /** Where the last copy stands. */
+    get status(): ClipboardStatus;
+    constructor();
+    disconnectedCallback(): void;
+    /** Copies `value` as a trigger click would. Resolves once the write has settled. */
+    copy(): Promise<void>;
+    private _write;
+    /** The pre-`navigator.clipboard` way, for pages without it (plain HTTP). */
+    private _copyByExecCommand;
+    private _reportOutcome;
+    private _setStatus;
+    updated(changed: Map<string, unknown>): void;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * `<anduin-clipboard-indicator>` — a ready-made copy icon button (duplicate
+ * icon that turns into a check while copied). `appearance`: `plain` (32×32,
+ * hover background; default) or `text` (bare inline icon).
+ */
+declare class AnduinClipboardIndicator extends LitElement {
+    static styles: CSSResult;
+    appearance: ClipboardIndicatorAppearance;
+    private _copied;
+    private _label;
+    private _link;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * `<anduin-clipboard-trigger>` — the click target. Wraps its child in an
+ * `anduin-tooltip` that says "Click to copy", then "✓ Copied to clipboard".
+ * An icon-only child (no text, no `label` / `aria-label`) is named "Copy <label>".
+ */
+declare class AnduinClipboardTrigger extends LitElement {
+    static styles: CSSResult;
+    private _status;
+    private _hovered;
+    private _link;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onClick;
+    private _onRootChange;
+    private _tooltip;
+    /** Offer an icon-only control a name; a control with its own words or name keeps them. */
+    private _nameControl;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * `<anduin-collapsible>` — a disclosure widget: an `<anduin-collapsible-trigger>`
+ * shows and hides an `<anduin-collapsible-content>`; an optional
+ * `<anduin-collapsible-icon>` rotates with it. The root has no layout box.
+ *
+ * - Uncontrolled (default): `default-open` sets the start state; clicks toggle it.
+ * - Controlled: once `open` is set (attribute or property), clicks only fire
+ *   `anduin-collapsible-open-change`; the consumer updates `open`.
+ */
+declare class AnduinCollapsible extends LitElement {
+    static styles: CSSResult;
+    /** Controlled open state. Setting it (attribute or property) switches to controlled mode. */
+    get open(): boolean;
+    set open(value: boolean);
+    private _open;
+    private _controlled;
+    /** Start state in uncontrolled mode. */
+    defaultOpen: boolean;
+    /** Ignores the trigger: clicks neither toggle nor fire an event. The open state still follows `open` / `default-open`. */
+    disabled: boolean;
+    /** Animation axis: `vertical` (height, default) or `horizontal` (width). */
+    direction: CollapsibleDirection;
+    /** `off`, or a duration such as `100ms`. Absent means 150ms. Read at every toggle. */
+    animation: string;
+    /** The content panel's id — the trigger's `aria-controls`. */
+    readonly contentId: string;
+    private _uncontrolledOpen;
+    get isControlled(): boolean;
+    /** The state the collapsible currently shows. */
+    get isOpen(): boolean;
+    get isHorizontal(): boolean;
+    get animationDuration(): number;
+    /** Toggles as a trigger click would: ignored while disabled. */
+    toggle(): void;
+    updated(): void;
+    private _broadcast;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * `<anduin-collapsible-content>` — the panel. Always in the DOM (child state is
+ * kept); shown / hidden with a height (or width, `direction="horizontal"`)
+ * animation. A horizontal panel's inner box fills the host's height.
+ */
+declare class AnduinCollapsibleContent extends LitElement {
+    static styles: CSSResult;
+    private _link;
+    private _el;
+    /** The state last applied to the panel; null until the first one, which never animates. */
+    private _shown;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    firstUpdated(): void;
+    private _onState;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * `<anduin-collapsible-icon>` — wraps an icon and rotates it to `rotation`
+ * degrees (default 90; negative turns counterclockwise) while open.
+ */
+declare class AnduinCollapsibleIcon extends LitElement {
+    static styles: CSSResult;
+    /** The angle, in whole degrees, the icon turns to when open. Unreadable values fall back to 90. */
+    rotation: string | number;
+    private _link;
+    private _el;
+    private _shown;
+    private get _openAngle();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    firstUpdated(): void;
+    updated(changed: Map<string, unknown>): void;
+    private _rest;
+    private _onState;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * `<anduin-collapsible-trigger>` — any click inside toggles the root. No layout
+ * box. Writes `aria-expanded` / `aria-controls` / `aria-disabled` on itself and
+ * on the element slotted in; a plain `span`/`div` with text becomes a
+ * `role="button"` tab stop that toggles on Enter / Space.
+ */
+declare class AnduinCollapsibleTrigger extends LitElement {
+    static styles: CSSResult;
+    private _link;
+    private _synced;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onKeyDown;
+    private _sync;
+    /**
+     * `anduin-button` keeps its `<button>` in a shadow root and has no
+     * `control-expanded` relay, so the expanded state is written onto that inner
+     * button directly (aria-controls cannot cross the shadow boundary).
+     */
+    private _relayIntoButton;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * `<anduin-combobox>` — the design repo's pick-from-list field: a text input that filters a list
+ * of predefined options. The value is always one of the items; typed text is only a filter, and
+ * the input reverts to the chosen item's label when the list closes.
+ *
+ * ```html
+ * <anduin-combobox>
+ *   <anduin-combobox-input placeholder="Search..."></anduin-combobox-input>
+ *   <anduin-combobox-content>
+ *     <anduin-combobox-empty>No results</anduin-combobox-empty>
+ *     <anduin-combobox-list>
+ *       <anduin-combobox-item value="us">United States</anduin-combobox-item>
+ *     </anduin-combobox-list>
+ *   </anduin-combobox-content>
+ * </anduin-combobox>
+ * ```
+ *
+ * `value` is written back on a pick (so uncontrolled markup works) and `change` fires with
+ * `{ value }`; a value set from outside updates the field without firing `change`.
+ */
+declare class AnduinCombobox extends PickerRoot {
+    static family: string;
+    /** Inline-block, as in the design repo: the field shrink-wraps to the input (an autocomplete is block). */
+    static styles: CSSResult;
+    private _query;
+    firstUpdated(): void;
+    updated(changed: PropertyValues<this>): void;
+    /** Marks the chosen item and, while closed, shows its label in the field. */
+    private _syncSelection;
+    protected openQuery(): string;
+    protected emptyVisible(query: string, nothingMatched: boolean): boolean;
+    protected panelVisible(): boolean;
+    protected onOpened(): void;
+    protected onClosed(): void;
+    protected onItemChosen(value: string): void;
+    fieldFocus(): void;
+    fieldInput(text: string): void;
+    /** Keyboard handling for the input (it keeps focus; the highlight is virtual). */
+    fieldKeyDown(e: KeyboardEvent): void;
+}
+
+/** `<anduin-combobox-content>` — the floating panel. `width` (px) pins its width; otherwise it shrink-wraps (min 160px). */
+declare class AnduinComboboxContent extends PickerContent {
+    static family: string;
+}
+
+/** `<anduin-combobox-empty>` — shown when a non-empty query matches nothing. */
+declare class AnduinComboboxEmpty extends PickerEmpty {
+    static family: string;
+}
+
+/** `<anduin-combobox-group>` — a labelled section (`role="group"`); hides itself when every item in it is filtered out. */
+declare class AnduinComboboxGroup extends PickerGroup {
+    static family: string;
+}
+
+/** `<anduin-combobox-input>` — the text field that opens, filters and drives the list. Chevron on the right. */
+declare class AnduinComboboxInput extends PickerField {
+    static family: string;
+    static styles: CSSResult[];
+    private _onKeyDown;
+    firstUpdated(): void;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * `<anduin-combobox-item value="…">Label</anduin-combobox-item>` — an option. `label` overrides the
+ * text used in the field and by the filter; `description` adds a second line; `disabled` keeps it
+ * visible but unpickable. The chosen item shows a check.
+ */
+declare class AnduinComboboxItem extends PickerItem {
+    static family: string;
+    static styles: CSSResultGroup[];
+    /** Secondary line under the label (or slot content into `slot="description"`). */
+    description: string;
+    private _hasSlottedDescription;
+    protected rowClass(): string;
+    protected renderContent(): TemplateResult<1>;
+    protected renderEnd(): TemplateResult<1>;
+}
+
+/** `<anduin-combobox-label>` — a group's heading. */
+declare class AnduinComboboxLabel extends PickerLabel {
+    static family: string;
+}
+
+/** `<anduin-combobox-list>` — the listbox. `max-height` caps it (any CSS length); `items` (JS) renders data. */
+declare class AnduinComboboxList extends PickerList {
+    static family: string;
+}
+
+/** `<anduin-combobox-separator>` — a divider between groups; hides when left dangling by the filter. */
+declare class AnduinComboboxSeparator extends PickerSeparator {
+    static family: string;
+}
+
 /**
  * A formatted date input. Displays a pattern such as `MM/dd/yyyy` and lets users
  * type digits into each segment; clicking a segment highlights it, and focus
@@ -435,6 +882,169 @@ declare class AnduinDateRangeStart extends AnduinDateRangePanel {
     protected readonly panelRole: "start";
 }
 
+/**
+ * Root coordinator. Renders nothing itself (`display: contents`).
+ *
+ * - Uncontrolled (no `open` attribute): the trigger, overlay, Escape and close
+ *   parts open/close it directly; `default-open` opens it on mount.
+ * - Controlled (`open="true|false"`): a request fires `anduin-dialog-open-change`
+ *   and then writes `open` itself, like the design repo (so it still closes when
+ *   the consumer only listens to `anduin-dialog-on-close`).
+ */
+declare class AnduinDialog extends LitElement {
+    static styles: CSSResult;
+    /** Controlled open state. Leave unset for uncontrolled. */
+    open: boolean | undefined;
+    /** Uncontrolled: start open. */
+    defaultOpen: boolean;
+    /** Escape closes the topmost dialog (default true). */
+    closeOnEscape: boolean;
+    /** Overlay click closes. Unset: true, except for an `alert` content. */
+    closeOnClickOutside: boolean | undefined;
+    private _visible;
+    private _focusFrame;
+    /** Whether the dialog is currently shown. */
+    get isOpen(): boolean;
+    private get _controlled();
+    /** This dialog's own content (never a nested dialog's). */
+    get contentElement(): AnduinDialogContent | null;
+    private get _trigger();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    render(): TemplateResult<1>;
+    /** Open or close as a user action would: controlled mode fires `anduin-dialog-open-change` first. */
+    requestOpen(wantOpen: boolean): void;
+    toggle(): void;
+    /** Overlay click: close, or shake when click-outside is off. */
+    requestCloseFromOutside(): void;
+    private get _closesOnClickOutside();
+    private _show;
+    private _hide;
+    private _attach;
+    private _detach;
+    /** Focus goes back to the trigger's control after the closed frame renders. */
+    private _focusTrigger;
+    private _onDocKeyDown;
+    /** ACL interop: an `anduin-modal-close` inside the dialog closes it too. */
+    private _onLegacyClose;
+}
+
+/** The scrolling middle region. `flush` drops its 16px 24px padding. */
+declare class AnduinDialogBody extends LitElement {
+    static styles: CSSResult;
+    flush: boolean;
+    render(): TemplateResult<1>;
+}
+
+/** Closes its dialog when anything inside it is clicked (both modes; ignores close-on-click-outside). */
+declare class AnduinDialogClose extends LitElement {
+    static styles: CSSResult;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onClick;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * The overlay + panel. Hidden until its dialog opens; then fixed over the
+ * viewport, body scroll locked, focus moved in and trapped.
+ */
+declare class AnduinDialogContent extends LitElement {
+    static styles: CSSResult[];
+    /** small (480) | medium (720) | large (960) | extraLarge (1160) | full | fitContent, or any CSS width. */
+    width: DialogWidth | string;
+    /** fill (75vh), or any CSS height. Unset: fits content. */
+    height: DialogHeight | string;
+    /** Move focus into the dialog on open (default true). */
+    autoFocus: boolean;
+    /** Alert dialog: role="alertdialog", focus on the first close action, overlay click does not close. */
+    alert: boolean;
+    /** Explicit accessible name; overrides the title. */
+    dialogLabel: string | null;
+    private _leaving;
+    private _shown;
+    private _holdsScrollLock;
+    private _leaveTimer;
+    private _focusFrame;
+    private get _dialog();
+    private get _panel();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    protected updated(changed: PropertyValues<this>): void;
+    private _applySizing;
+    /** Follow the owning dialog's open state (called by the root). */
+    syncOpen(): void;
+    private _enter;
+    private _exit;
+    private _releaseScroll;
+    /** Own descendants matching `selector` (never a nested dialog's). */
+    private _own;
+    /** `[autofocus]` / `[data-autofocus]` first, then (alert) the first close action, else the panel. */
+    private _focusInitial;
+    /** Keep Tab / Shift+Tab inside the panel (called by the root while topmost). */
+    trapTab(e: KeyboardEvent): void;
+    /** Play the "can't dismiss" nudge (overlay click with click-outside off). */
+    shake(): void;
+    /**
+     * Name / describe the panel from this content's own title and description.
+     * IDREFs cannot cross the shadow boundary, so their text is copied into
+     * `aria-label` / `aria-description`, as the design repo does.
+     */
+    refreshAccessibleText(): void;
+    private _onOverlayClick;
+    render(): TemplateResult<1>;
+}
+
+/** Supporting text under the title; also becomes the panel's accessible description. */
+declare class AnduinDialogDescription extends DialogTextElement {
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+}
+
+/** Right-aligned action row. `divider` draws a line above it. */
+declare class AnduinDialogFooter extends LitElement {
+    static styles: CSSResult;
+    divider: boolean;
+    render(): TemplateResult<1>;
+}
+
+/** Title + description block. `divider` draws a line below it. */
+declare class AnduinDialogHeader extends LitElement {
+    static styles: CSSResult;
+    divider: boolean;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * A full-viewport backdrop around its children; a click on the backdrop itself
+ * (not on the children) asks the dialog to close. `anduin-dialog-content`
+ * already draws its own overlay; this is for custom compositions.
+ */
+declare class AnduinDialogOverlay extends LitElement {
+    static styles: CSSResult;
+    private _onClick;
+    render(): TemplateResult<1>;
+}
+
+/** `<h2>` heading with a built-in close (×) button; `show-close-button="false"` hides it. */
+declare class AnduinDialogTitle extends DialogTextElement {
+    static styles: CSSResult;
+    showCloseButton: boolean;
+    render(): TemplateResult<1>;
+}
+
+/** Wraps the control that opens the dialog; click / Enter / Space toggles it. */
+declare class AnduinDialogTrigger extends LitElement {
+    static styles: CSSResult;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onClick;
+    private _onKeyDown;
+    render(): TemplateResult<1>;
+}
+
 declare class AnduinDivider extends LitElement {
     static styles: CSSResult;
     direction: string;
@@ -891,35 +1501,220 @@ declare class AnduinLoadingState extends LitElement {
 declare class AnduinMenu extends LitElement {
     static styles: CSSResult;
     open: boolean;
-    placement: 'bottom-start' | 'bottom-end' | 'bottom' | 'top-start' | 'top-end' | 'top';
+    /**
+     * Old API: `bottom-start | bottom | bottom-end | top-start | top | top-end`. With the design parts, any of the
+     * 12 design placements (`top|bottom|left|right` × `start|center|end`).
+     */
+    placement: string;
+    defaultOpen: boolean;
+    disabled: boolean;
+    offsetX: number;
+    offsetY: number;
+    /** True when the children are design parts rather than `slot="trigger"` + items. */
+    private _design;
     private _triggerEl;
     private _panelEl;
     private _onTriggerClick;
+    /** Whether the design parts are in use (rather than `slot="trigger"`). */
+    get isDesignMode(): boolean;
+    private _detectMode;
+    private _ownParts;
+    /* Excluded from this release type: triggerPart */
+    private get _contentPart();
+    /** Design API: ask for a new open state. Fires `anduin-menu-open-change`, then applies it. */
+    requestOpen(want: boolean): void;
+    /* Excluded from this release type: toggleFromTrigger */
+    /* Excluded from this release type: openAndFocus */
+    private _overlay;
+    private _onDesignPointerDown;
+    private _onItemCommit;
+    private _applyDesignOpen;
     private _onOutsideClick;
     private _onItemClick;
     private _onScrollOrResize;
     connectedCallback(): void;
     disconnectedCallback(): void;
+    private _defaultOpenApplied;
+    willUpdate(changed: Map<string, unknown>): void;
     updated(changed: Map<string, unknown>): void;
     private _updatePosition;
     render(): TemplateResult<1>;
 }
 
-declare class AnduinMenuItem extends LitElement {
-    static styles: CSSResult;
-    icon: string;
-    variant: 'default' | 'danger';
-    disabled: boolean;
-    private _onClick;
+/**
+ * The menu popup (`role="menu"`), shown in the top layer next to the trigger. With `standalone`, it renders inline
+ * with no popup chrome — for a menu list inside a popover or a panel.
+ */
+declare class AnduinMenuContent extends MenuSurface {
+    static styles: CSSResult[];
+    /** Accessible name; defaults to the trigger's text. */
+    label: string;
+    /** Render inline, without a trigger or popup. Read once, on connect. */
+    standalone: boolean;
+    firstUpdated(): void;
+    protected _beforeShow(): void;
+    protected _anchor(): {
+        ref: HTMLElement;
+        placement: "top-start" | "top-center" | "top-end" | "right-start" | "right-center" | "right-end" | "bottom-start" | "bottom-center" | "bottom-end" | "left-start" | "left-center" | "left-end";
+        dx: number;
+        dy: number;
+    } | null;
     render(): TemplateResult<1>;
 }
 
-declare class AnduinModal extends LitElement {
+/** Groups related items (`role="group"`), usually under an `anduin-menu-label`. */
+declare class AnduinMenuGroup extends LitElement {
     static styles: CSSResult;
-    open: boolean;
-    heading: string;
-    hideHeader: boolean;
-    hideFooter: boolean;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * A menu item. Old API: `icon`, `variant="default|danger"`, `disabled`, fires `anduin-menu-item:click`.
+ * Design API adds `start-icon`, `variant="gray"`, `checked` (+ `radio`), `inset`, `loading`, `href` (+ `open-new-tab`),
+ * `size="medium|free"`, `description` (or `slot="description"`), `label`, and the cancelable
+ * `anduin-menu-item-selected` event. Inside `anduin-menu-content` it also takes the design repo's metrics
+ * (32px row, 8px icon gap) and roving focus.
+ */
+declare class AnduinMenuItem extends LitElement {
+    static shadowRootOptions: {
+        delegatesFocus: boolean;
+        clonable?: boolean;
+        customElementRegistry?: CustomElementRegistry;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    static styles: CSSResult;
+    /** Old API: icon before the label. Same as `start-icon`. */
+    icon: string;
+    /** Design API: icon before the label. */
+    startIcon: string;
+    /** `default` / `gray` (same thing) or `danger`. */
+    variant: 'default' | 'gray' | 'danger';
+    disabled: boolean;
+    /** Present (any value but `"false"` means on): a checkable item showing a check. Absent: a plain item. */
+    checked: boolean | undefined;
+    /** With `checked`: one of a set where a single option is on (announced as a radio item). */
+    radio: boolean;
+    /** Indent the label to line up with items that have an icon. */
+    inset: boolean;
+    /** Busy: a spinner replaces the icon and activation is blocked. */
+    loading: boolean;
+    /** Render as a link. */
+    href: string;
+    openNewTab: boolean;
+    /** `medium` (32px row, default) or `free` (content height). */
+    size: 'medium' | 'free';
+    /** Second line under the label. Rich content can go in `slot="description"` instead. */
+    description: string;
+    /** Accessible name for the item when its text isn't enough. */
+    label: string;
+    private _design;
+    private _slottedDescription;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onHostClickCapture;
+    private _onClick;
+    private _onKeyDown;
+    private _onPointerEnter;
+    private _onDescriptionSlotChange;
+    render(): TemplateResult<1>;
+}
+
+/** A non-interactive heading inside a menu. */
+declare class AnduinMenuLabel extends LitElement {
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+}
+
+/** A 1px divider between menu sections. */
+declare class AnduinMenuSeparator extends LitElement {
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * A nested menu: holds an `anduin-menu-sub-trigger` and an `anduin-menu-sub-content`. Opens on hover (and stays
+ * open while the pointer is over the trigger or the panel), on click, and on ArrowRight / Enter / Space.
+ */
+declare class AnduinMenuSub extends LitElement {
+    static styles: CSSResult;
+    /** Where the sub-menu opens relative to its trigger (default `right-start`; flips when there's no room). */
+    placement: string;
+    private _open;
+    private _closeTimer;
+    get open(): boolean;
+    private _own;
+    /* Excluded from this release type: triggerPart */
+    /* Excluded from this release type: contentPart */
+    setOpen(open: boolean): void;
+    /** Opens and moves focus to the first item of the sub-menu. */
+    openAndFocusFirst(): Promise<void>;
+    /** Closes and returns focus to the sub-trigger. */
+    closeAndFocusTrigger(): void;
+    /* Excluded from this release type: scheduleClose */
+    /* Excluded from this release type: cancelClose */
+    disconnectedCallback(): void;
+    render(): TemplateResult<1>;
+}
+
+/** The panel of a sub-menu. ArrowLeft or Escape inside it closes it and returns focus to the sub-trigger. */
+declare class AnduinMenuSubContent extends MenuSurface {
+    static styles: CSSResult;
+    private get _sub();
+    firstUpdated(): void;
+    protected _anchor(): {
+        ref: AnduinMenuSubTrigger;
+        placement: "top-start" | "top-center" | "top-end" | "right-start" | "right-center" | "right-end" | "bottom-start" | "bottom-center" | "bottom-end" | "left-start" | "left-center" | "left-end";
+        dx: number;
+        dy: number;
+    } | null;
+    protected _handleOwnKey(e: KeyboardEvent): boolean;
+    private _onPointerEnter;
+    private _onPointerLeave;
+    render(): TemplateResult<1>;
+}
+
+/** The item that opens a sub-menu: an item row with a trailing chevron. */
+declare class AnduinMenuSubTrigger extends LitElement {
+    static shadowRootOptions: {
+        delegatesFocus: boolean;
+        clonable?: boolean;
+        customElementRegistry?: CustomElementRegistry;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    static styles: CSSResult;
+    disabled: boolean;
+    inset: boolean;
+    startIcon: string;
+    private _expanded;
+    private get _sub();
+    /* Excluded from this release type: setExpanded */
+    private _onPointerEnter;
+    private _onPointerLeave;
+    private _onClick;
+    private _onKeyDown;
+    render(): TemplateResult<1>;
+}
+
+/** Wraps the element that opens the menu. Click toggles; Enter/Space/ArrowDown open on the first item, ArrowUp on the last. */
+declare class AnduinMenuTrigger extends LitElement {
+    static styles: CSSResult;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onClick;
+    private _onKeyDown;
+    render(): TemplateResult<1>;
+}
+
+declare class AnduinModal extends LitElement {
+    static styles: CSSResult[];
+    open: boolean;
+    heading: string;
+    hideHeader: boolean;
+    hideFooter: boolean;
     maxWidth: "480" | "600" | "720" | "960" | "1160" | string;
     fullscreen: boolean;
     private _leaving;
@@ -975,15 +1770,86 @@ declare class AnduinNavigation extends LitElement {
     value: string | null;
     theme: NavigationTheme;
     alignment: NavigationAlignment;
-    private internalValue;
-    private get isControlled();
-    private get selection();
+    protected internalValue: string;
+    protected get isControlled(): boolean;
+    protected get selection(): string;
     connectedCallback(): void;
     disconnectedCallback(): void;
     updated(): void;
-    private get items();
-    private syncItems;
+    protected get items(): AnduinNavigationItem[];
+    protected syncItems(): void;
     private onItemClick;
+    /** Reacts to an item activation. Subclasses (e.g. anduin-navigation-bar) override the event contract. */
+    protected handleItemClick(clicked: string): void;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * The design repo's `anduin-navigation-bar`: primary navigation between peer pages.
+ *
+ * Selection is uncontrolled with `default-value`, controlled with `value`, and falls back to the first
+ * item when neither is set. Every activation fires `anduin-navigation-bar-value-change` (`detail: { value }`).
+ * When the items no longer fit, previous/next arrow buttons appear and the active item is scrolled into view.
+ * Items stay ordinary light-DOM children, so they can be wrapped (e.g. in a tooltip trigger).
+ *
+ * Built on `anduin-navigation`'s selection model; `anduin-navigation` itself is unchanged.
+ */
+declare class AnduinNavigationBar extends AnduinNavigation {
+    static styles: CSSResult;
+    private overflowing;
+    private viewport;
+    private resizeObserver?;
+    private mutationObserver?;
+    private layoutFrame;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    willUpdate(changed: Map<PropertyKey, unknown>): void;
+    firstUpdated(): void;
+    /** Items owned by this bar (nested bars keep their own). */
+    protected get items(): AnduinNavigationBarItem[];
+    protected syncItems(): void;
+    protected handleItemClick(clicked: string): void;
+    private refreshObserved;
+    private scheduleLayout;
+    private updateLayout;
+    private scrollOneItem;
+    private scheduleScrollToValue;
+    private scrollToItem;
+    private renderArrow;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * The design repo's `anduin-navigation-bar-item`. Renders a native link when `href` is set, otherwise a
+ * native button. `selected` (when present) overrides the bar's selection for this item.
+ */
+declare class AnduinNavigationBarItem extends AnduinNavigationItem {
+    static shadowRootOptions: {
+        delegatesFocus: boolean;
+        clonable?: boolean;
+        customElementRegistry?: CustomElementRegistry;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    static styles: CSSResult;
+    /** Design boolean: `disabled="false"` is enabled. */
+    disabled: boolean;
+    /** Opens `href` in a new tab (`target="_blank"`, `rel="noreferrer noopener"`). */
+    openNewTab: boolean;
+    /**
+     * Per-item selection override (attribute `selected`, design boolean). Unset (`null` / `undefined`, or the
+     * attribute removed) means "follow the bar". Typed `boolean` to stay compatible with the base item.
+     */
+    selected: boolean;
+    /** Set by the parent anduin-navigation-bar; not a consumer-facing attribute. */
+    barSelected: boolean;
+    /** Mirrored onto the inner control, e.g. to name an icon-only item. */
+    controlLabel: string | null;
+    /** Whether the item renders as selected: the `selected` override, else the bar's value. */
+    get isSelected(): boolean;
+    updated(): void;
+    private onControlClick;
     render(): TemplateResult<1>;
 }
 
@@ -1003,6 +1869,57 @@ declare class AnduinNavigationItem extends LitElement {
     render(): TemplateResult<1>;
 }
 
+/**
+ * `<anduin-non-ideal-state>` — the design repo's empty / unavailable / error state.
+ *
+ * Fills its parent (`width` and `height: 100%`) and centers its regions in a column with a 12px gap. Compose it
+ * from any of `anduin-non-ideal-state-icon`, `-title`, `-description` and `-action`; a region left out takes no
+ * space. Give the parent an intentional height.
+ */
+declare class AnduinNonIdealState extends LitElement {
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+}
+
+/** `<anduin-non-ideal-state-action>` — action region; holds one or more buttons or links, intentionally unstyled. */
+declare class AnduinNonIdealStateAction extends LitElement {
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * `<anduin-non-ideal-state-description>` — secondary text in the muted foreground colour, 13px / 20px. (The design
+ * repo inherits both from its page base, which is 13px / 20px; ACL pages do not set a body line-height, so it is
+ * explicit here.)
+ */
+declare class AnduinNonIdealStateDescription extends LitElement {
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * `<anduin-non-ideal-state-icon>` — icon region; its content is intentionally unstyled.
+ *
+ * Sets `aria-hidden="true"` on itself unless the consumer already wrote an `aria-hidden` (e.g. `"false"` for an
+ * icon that carries meaning the title does not).
+ */
+declare class AnduinNonIdealStateIcon extends LitElement {
+    static styles: CSSResult;
+    connectedCallback(): void;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * `<anduin-non-ideal-state-title>` — the title, exposed as a heading (`role="heading"`, `aria-level` from
+ * `heading-level`, default 2). 17px / 28px semibold.
+ */
+declare class AnduinNonIdealStateTitle extends LitElement {
+    static styles: CSSResult;
+    /** Heading level, 1–6. Anything else falls back to 2. */
+    headingLevel: number | string | null;
+    render(): TemplateResult<1>;
+}
+
 /**
  * Page navigation controls for paginated content. Renders a row of page-number
  * buttons with previous/next navigators, ellipsis menus for skipped ranges, and
@@ -1061,20 +1978,49 @@ declare class AnduinPaginationLastPage extends BoundaryButton {
 declare class AnduinPopover extends LitElement {
     static styles: CSSResult;
     open: boolean;
-    placement: 'bottom-start' | 'bottom-end' | 'bottom' | 'top-start' | 'top-end' | 'top';
+    /**
+     * Old API: `bottom-start | bottom | bottom-end | top-start | top | top-end`. With the design parts, any of the
+     * 12 design placements (`top|bottom|left|right` × `start|center|end`).
+     */
+    placement: string;
     fullWidth: boolean;
+    defaultOpen: boolean;
+    disabled: boolean;
+    offsetX: number;
+    offsetY: number;
+    closeOnEscape: boolean;
+    closeOnClickOutside: boolean;
+    /** True when the children are design parts rather than `slot="trigger"` + panel content. */
+    private _design;
     private _visible;
     private _closing;
     private _triggerEl;
     private _panelEl;
     private _closeTransitionEndHandler;
     private _onTriggerClick;
+    /** Whether the design parts are in use (rather than `slot="trigger"`). */
+    get isDesignMode(): boolean;
+    private _detectMode;
+    private _ownParts;
+    /* Excluded from this release type: triggerPart */
+    private get _contentPart();
+    /**
+     * Design API: ask for a new open state. Fires `anduin-popover-open-change`, then applies it. (The design repo's
+     * controlled mode writes `open` itself as well, so controlled and uncontrolled behave alike.)
+     */
+    requestOpen(want: boolean): void;
+    /* Excluded from this release type: toggleFromTrigger */
+    private _overlay;
+    private _onDesignPointerDown;
     private _onOutsideClick;
     private _onScrollOrResize;
     private _onPopoverClose;
     connectedCallback(): void;
     disconnectedCallback(): void;
+    private _defaultOpenApplied;
+    willUpdate(changed: Map<string, unknown>): void;
     updated(changed: Map<string, unknown>): void;
+    private _applyDesignOpen;
     private _cancelCloseAnimation;
     private _startCloseAnimation;
     private _updatePosition;
@@ -1087,6 +2033,52 @@ declare class AnduinPopoverClose extends LitElement {
     render(): TemplateResult<1>;
 }
 
+/**
+ * The floating panel. Promoted to the top layer (Popover API), positioned against the trigger every frame while
+ * open, flips when there's no room, traps Tab and moves focus inside on open (unless `auto-focus="false"`).
+ */
+declare class AnduinPopoverContent extends LitElement {
+    static styles: CSSResult;
+    /** Move focus to the first focusable element on open (default true). */
+    autoFocus: boolean;
+    /** Marks the popup `aria-modal="true"`. */
+    modal: boolean;
+    /** Accessible name; defaults to the text of an `anduin-popover-title` inside. */
+    label: string;
+    private _popup;
+    private _active;
+    private _shown;
+    private _stopTracking;
+    private _focusFrame;
+    /* Excluded from this release type: setActive */
+    firstUpdated(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onKeyDown;
+    private _sync;
+    private _accessibleName;
+    private _show;
+    private _hide;
+    private _position;
+    render(): TemplateResult<1>;
+}
+
+/** Heading for the content panel, with a built-in close (×) button. */
+declare class AnduinPopoverTitle extends LitElement {
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+}
+
+/** Wraps the element that opens the popover. Click, Enter and Space toggle it. */
+declare class AnduinPopoverTrigger extends LitElement {
+    static styles: CSSResult;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onClick;
+    private _onKeyDown;
+    render(): TemplateResult<1>;
+}
+
 declare class AnduinProgress extends LitElement {
     static styles: CSSResult;
     percent: string;
@@ -1186,6 +2178,463 @@ declare class AnduinResizablePanelGroup extends LitElement {
     render(): TemplateResult<1>;
 }
 
+/**
+ * `<anduin-select>` — the design repo's compound single-value select: a free-form
+ * `<anduin-select-trigger>` (usually an `anduin-button`) and an `<anduin-select-content>` popup holding an
+ * optional search input, header/footer, empty state and an `<anduin-select-list>` of items.
+ *
+ * The parts are light-DOM children that find this root with `closest()`; the root drives them imperatively
+ * (selected/highlighted/hidden state, the selected label, the clear ✕) whenever its value, the query or the
+ * markup changes. `anduin-dropdown` (options as a JS array) is a separate element and keeps its own API.
+ */
+declare class AnduinSelect extends LitElement {
+    static styles: CSSResult[];
+    /** The selected item's value. Set it to control the select; a pick also writes it back (reflected). */
+    value: string;
+    /** Where the popup opens relative to the trigger. */
+    placement: SelectPlacement;
+    /** While true the list shows a spinner and selection/navigation pause. `loading="false"` is false. */
+    loading: boolean;
+    /** Fixed row height in px for every item (default 32). */
+    itemHeight: number | null;
+    private _announcement;
+    private _open;
+    private _query;
+    private _highlighted;
+    private _ignorePointer;
+    private _typeahead;
+    private _typeaheadTimer;
+    private _syncQueued;
+    private _focusFrame;
+    private _rankedOrder;
+    private _observer;
+    /** Whether the dropdown is open. */
+    get open(): boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected updated(changed: PropertyValues<this>): void;
+    render(): TemplateResult<1>;
+    private _own;
+    /* Excluded from this release type: _trigger */
+    /* Excluded from this release type: _content */
+    /* Excluded from this release type: _list */
+    /* Excluded from this release type: _input */
+    /* Excluded from this release type: _items */
+    /** The label the trigger shows for a value: the matching item's label, else the raw value. */
+    labelFor(value: string): string;
+    /** Re-derive every part's state on the next microtask (parts call this when they connect or change). */
+    requestSync(): void;
+    private _sync;
+    private _applyFilter;
+    /** The accessible name: the trigger's `label`/`aria-label`, an enclosing field's label, else the placeholder. */
+    private _comboboxName;
+    private _syncTrigger;
+    /** Opens the dropdown. */
+    show(): void;
+    /** Closes the dropdown without changing the value. */
+    hide(): void;
+    /** Opens a closed dropdown, closes an open one. */
+    toggle(): void;
+    private _close;
+    private _teardownOpen;
+    /** Clears the value (firing `change` with `''`), as the ✕ and Delete/Backspace do. */
+    clear(): void;
+    private _selectValue;
+    private _focusTrigger;
+    private _onItemSelected;
+    private _onDocPointerDown;
+    private _onDocPointerMove;
+    private _onDocKeyDown;
+    private _navigable;
+    private _setHighlight;
+    private _scrollIntoView;
+    private _move;
+    private _highlightEdge;
+    private _selectHighlighted;
+    private _typeaheadKey;
+    /* Excluded from this release type: _hover */
+    /* Excluded from this release type: _setQuery */
+    /* Excluded from this release type: _onTriggerKeyDown */
+    /* Excluded from this release type: _onInputKeyDown */
+    /* Excluded from this release type: _onTriggerClick */
+}
+
+/** A small ✕ for the trigger, shown only while a value is selected. Clicking it clears without opening. */
+declare class AnduinSelectClear extends LitElement {
+    static styles: CSSResult;
+    visible: boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onClick;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * The floating panel. Its light-DOM children (input, header, empty, list, footer) are slotted into a top-layer
+ * popover positioned against the trigger. `width` pins a width in px (or any CSS length); otherwise it
+ * shrink-wraps with a 160px minimum.
+ */
+declare class AnduinSelectContent extends LitElement {
+    static styles: CSSResult;
+    width: string | null;
+    private _anchor;
+    private _placement;
+    private _list;
+    private _frame;
+    private _last;
+    /* Excluded from this release type: popup */
+    get isOpen(): boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected updated(changed: PropertyValues<this>): void;
+    render(): TemplateResult<1>;
+    /* Excluded from this release type: _show */
+    /* Excluded from this release type: _hide */
+    private _reposition;
+}
+
+/** Shown in place of the list when the search matches nothing. */
+declare class AnduinSelectEmpty extends LitElement {
+    static styles: CSSResult;
+    connectedCallback(): void;
+    render(): TemplateResult<1>;
+}
+
+/** Content pinned below the list, with a full-width divider above it. */
+declare class AnduinSelectFooter extends LitElement {
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+}
+
+/** Groups items under an `<anduin-select-label>`; hides when the search leaves it empty. */
+declare class AnduinSelectGroup extends LitElement {
+    static styles: CSSResult;
+    connectedCallback(): void;
+    render(): TemplateResult<1>;
+}
+
+/** Content pinned above the list, with a full-width divider below it. */
+declare class AnduinSelectHeader extends LitElement {
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * The search field inside the content. Typing filters the items by label (case-insensitive substring), or by
+ * a custom `filter` / `rank` function set as a JS property. `size`: small (24px) / default (32px) / large (40px).
+ */
+declare class AnduinSelectInput extends LitElement {
+    static styles: CSSResult;
+    placeholder: string;
+    size: SelectInputSize;
+    /** Accessible name for the search box (the placeholder otherwise). */
+    label: string;
+    private _filter;
+    private _rank;
+    /** Custom match predicate (JS property). */
+    get filter(): SelectItemFilter | null;
+    set filter(fn: SelectItemFilter | null);
+    /** Custom scoring function: matches and orders (JS property). Wins over `filter`. */
+    get rank(): SelectItemRank | null;
+    set rank(fn: SelectItemRank | null);
+    private get _inputEl();
+    /** The current query text. */
+    get query(): string;
+    connectedCallback(): void;
+    focusInput(): void;
+    /* Excluded from this release type: _reset */
+    /* Excluded from this release type: _syncAria */
+    private _onInput;
+    private _onKeyDown;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * One option. `value` is what the select reports; `label` is what the trigger shows and search matches
+ * (default: the item's text). `description` (or a `slot="description"` child) adds a second line,
+ * `start-icon` an icon, `disabled` keeps it visible but unselectable, `size="free"` lets custom content set
+ * the height. Fires the cancelable `anduin-select-item-selected` when picked.
+ */
+declare class AnduinSelectItem extends LitElement {
+    static styles: CSSResult;
+    value: string;
+    label: string | null;
+    description: string;
+    disabled: boolean;
+    size: SelectItemSize;
+    startIcon: string;
+    /** Set by the root. */
+    selected: boolean;
+    /** Set by the root. */
+    highlighted: boolean;
+    private _hasSlottedDescription;
+    /** The label used by the trigger, search and typeahead. */
+    get labelText(): string;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected updated(changed: PropertyValues<this>): void;
+    private _onClick;
+    private _onPointer;
+    private _onPointerMove;
+    private _onDescriptionSlotChange;
+    render(): TemplateResult<1>;
+}
+
+/** A group's heading. */
+declare class AnduinSelectLabel extends LitElement {
+    static styles: CSSResult;
+    connectedCallback(): void;
+    render(): TemplateResult<1>;
+}
+
+/** The scrolling `listbox` of items. `max-height` caps it with any CSS length (or `none`). */
+declare class AnduinSelectList extends LitElement {
+    static styles: CSSResult;
+    maxHeight: string | null;
+    loading: boolean;
+    connectedCallback(): void;
+    protected updated(changed: PropertyValues<this>): void;
+    render(): TemplateResult<1>;
+}
+
+/** Shows the selected item's label inside the trigger, or `placeholder` (muted) when nothing is selected. */
+declare class AnduinSelectSelectedLabel extends LitElement {
+    static styles: CSSResult;
+    placeholder: string;
+    connectedCallback(): void;
+    protected updated(changed: PropertyValues<this>): void;
+    /* Excluded from this release type: _show */
+    render(): TemplateResult<1>;
+}
+
+/** A divider between groups; hides when the search leaves nothing on one side of it. */
+declare class AnduinSelectSeparator extends LitElement {
+    static styles: CSSResult;
+    connectedCallback(): void;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * Generic container that toggles the dropdown on click and handles the keyboard. Put any content inside —
+ * usually `<anduin-button end-icon="caretDown">` holding an `<anduin-select-selected-label>`. With a slotted
+ * button the combobox semantics go on its inner `<button>`; otherwise the trigger host itself is the focusable
+ * combobox. `label` (or `aria-label`) names it.
+ */
+declare class AnduinSelectTrigger extends LitElement {
+    static styles: CSSResult;
+    label: string;
+    private _root;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected updated(): void;
+    render(): TemplateResult<1>;
+    private _onClick;
+    private _onKeyDown;
+    /** The slotted `anduin-button` (or native button) that takes focus, if any. */
+    private _control;
+    /* Excluded from this release type: _isDisabled */
+    /* Excluded from this release type: _focusControl */
+    /* Excluded from this release type: _syncAria */
+    private _lastName;
+}
+
+/**
+ * `<anduin-sheet>` — the design repo's sheet: a panel that slides in from a
+ * viewport edge. Root of `anduin-sheet-trigger` + `anduin-sheet-content`.
+ * (`anduin-drawer` keeps its own API.)
+ *
+ * - Uncontrolled (default): the trigger toggles it, the overlay / Escape /
+ *   `anduin-sheet-close` close it; `default-open` opens it on mount.
+ * - Controlled: once `open` is set (attribute or property), every request fires
+ *   `anduin-sheet-open-change` and then applies itself, as the design repo does.
+ */
+declare class AnduinSheet extends LitElement {
+    static styles: CSSResult;
+    /** Controlled open state. Setting it (attribute or property) switches to controlled mode. */
+    get open(): boolean;
+    set open(value: boolean);
+    private _open;
+    private _controlled;
+    /** Uncontrolled: open on mount. Ignored in controlled mode. */
+    defaultOpen: boolean;
+    /** Edge the panel slides in from. */
+    side: SheetSide;
+    /** `false` keeps Escape from closing the sheet. */
+    closeOnEscape: boolean;
+    private _visible;
+    private _trigger;
+    private _content;
+    private _focusFrame;
+    /** Whether the sheet is currently open. */
+    get isOpen(): boolean;
+    private get _isControlled();
+    private get _side();
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected updated(changed: PropertyValues<this>): void;
+    /** Opens or closes the sheet the way a trigger would (fires `anduin-sheet-open-change` when controlled). */
+    requestOpen(wantOpen: boolean): void;
+    private _setContent;
+    private _maybeShowInitial;
+    private _show;
+    private _hide;
+    private _focusTrigger;
+    private _stopAtSelf;
+    private _onRegister;
+    private _onCommand;
+    private _onDocKeyDown;
+    render(): TemplateResult<1>;
+}
+
+/** `<anduin-sheet-close>` — clicking anything inside it closes the enclosing sheet. */
+declare class AnduinSheetClose extends HTMLElement {
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onClick;
+}
+
+/**
+ * `<anduin-sheet-content>` — the panel of an `anduin-sheet`. Fixed to a viewport
+ * edge (the root's `side`), it slides in over a transparent overlay that closes it
+ * on click. Modal by default: body scroll locked, Tab trapped, `aria-modal`.
+ * `modal="false"` lets the page stay in use; `dock="true"` splits the viewport
+ * instead of covering it (implies non-modal). `width` takes small / medium /
+ * large / extraLarge / fitContent or any CSS length; `resizable="true"` adds a
+ * drag handle on the edge facing the page.
+ */
+declare class AnduinSheetContent extends LitElement {
+    static styles: CSSResult;
+    /** Splits the viewport instead of covering the page. Implies non-modal. */
+    dock: boolean;
+    /** `false` keeps the page usable: no overlay, no scroll lock, no focus trap. Ignored while docked. */
+    modal: boolean;
+    /** Shows a drag handle on the edge facing the page. */
+    resizable: boolean;
+    /** `false` leaves focus where it was on open. Otherwise focus goes to `[autofocus]` / `[data-autofocus]` or the panel. */
+    autoFocus: boolean;
+    /** small (320) · medium (360) · large (400) · extraLarge (640) · fitContent, or any CSS length. Height for top/bottom. */
+    width: SheetWidth;
+    private _shown;
+    private _entered;
+    private _side;
+    private _dragging;
+    private _closing;
+    private _hideToken;
+    private _releaseLock;
+    private _dockListeners;
+    private _drag;
+    /** The side the panel is (or will be) anchored to. */
+    get side(): SheetSide;
+    /** Whether the open panel blocks the page. A docked panel never does. */
+    get isModal(): boolean;
+    /** Whether the panel is on screen (shown and not closing). */
+    get isPanelOpen(): boolean;
+    get panel(): HTMLElement | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    protected updated(changed: PropertyValues<this>): void;
+    /** Moves the panel to another edge without replaying the open animation. */
+    setSide(side: SheetSide): void;
+    /** Slides the panel in from `side`. */
+    show(side: SheetSide): Promise<void>;
+    /** Slides the panel out, then hides it and hands back the scroll lock / page inset. */
+    hide(): void;
+    /** Called by the sheet's dock toggle. */
+    requestDock(docked: boolean): void;
+    private _applyModalState;
+    private _panelSize;
+    private _syncDockInset;
+    private _applyAccessibleName;
+    private _focusInitial;
+    private _onDocKeyDown;
+    private _onWindowResize;
+    private _onDockToggle;
+    private _onDockRegister;
+    /** `anduin-drawer-close` / `anduin-modal-close` inside the panel close the sheet too. */
+    private _onLegacyClose;
+    private _onOverlayClick;
+    private _onResizeStart;
+    private _onResizeMove;
+    private _onResizeEnd;
+    private _onResizeKeyDown;
+    private _clamp;
+    private _applySize;
+    render(): TemplateResult<1>;
+    /** Whether focus currently sits inside this panel (used by the root to return focus on close). */
+    containsFocus(): boolean;
+}
+
+/** `<anduin-sheet-description>` — subdued supporting text under the title. Describes the panel. */
+declare class AnduinSheetDescription extends LitElement {
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * `<anduin-sheet-dock-toggle>` — clicking anything inside it flips the enclosing
+ * panel between docked and floating. Put the docked-state control in
+ * `anduin-sheet-dock-toggle-on` and the floating-state one in `-off`.
+ */
+declare class AnduinSheetDockToggle extends HTMLElement {
+    private _docked;
+    private _branches;
+    /** Whether the enclosing panel is docked. */
+    get docked(): boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** Called by the panel whenever its `dock` changes. */
+    setDocked(docked: boolean): void;
+    private _onClick;
+    private _onBranch;
+}
+
+declare abstract class AnduinSheetDockToggleBranch extends HTMLElement {
+    protected abstract readonly showWhenDocked: boolean;
+    connectedCallback(): void;
+    /** Hidden rather than removed, so the consumer's control keeps its own state. */
+    setDocked(docked: boolean): void;
+}
+
+/** `<anduin-sheet-dock-toggle-off>` — shown while the panel floats (so it offers to dock). */
+declare class AnduinSheetDockToggleOff extends AnduinSheetDockToggleBranch {
+    protected readonly showWhenDocked = false;
+}
+
+/** `<anduin-sheet-dock-toggle-on>` — shown while the panel is docked (so it offers to float). */
+declare class AnduinSheetDockToggleOn extends AnduinSheetDockToggleBranch {
+    protected readonly showWhenDocked = true;
+}
+
+/** `<anduin-sheet-footer>` — action area pushed to the bottom of the panel, 16px padding. */
+declare class AnduinSheetFooter extends LitElement {
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+}
+
+/** `<anduin-sheet-header>` — groups title and description with 16px padding. */
+declare class AnduinSheetHeader extends LitElement {
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+}
+
+/** `<anduin-sheet-title>` — the sheet's `<h2>` heading, with a built-in close (×) button. Names the panel. */
+declare class AnduinSheetTitle extends LitElement {
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+}
+
+/** `<anduin-sheet-trigger>` — toggles its sheet on click, Enter or Space. */
+declare class AnduinSheetTrigger extends LitElement {
+    static styles: CSSResult;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onClick;
+    private _onKeyDown;
+    render(): TemplateResult<1>;
+}
+
 /**
  * anduin-sidebar — a vertical navigation region for an application's primary
  * sections. It organises navigable entries into labelled groups, highlights the
@@ -1343,7 +2792,7 @@ declare class AnduinSpinner extends LitElement {
 }
 
 declare class AnduinSuggestion extends LitElement {
-    static styles: CSSResult;
+    static styles: CSSResult[];
     value: string;
     size: 'small' | 'default' | 'large';
     disabled: boolean;
@@ -1382,6 +2831,54 @@ declare class AnduinSuggestion extends LitElement {
     render(): TemplateResult<1>;
 }
 
+/**
+ * `<anduin-switch>` — the design repo's name and API for a toggle switch
+ * (`anduin-switcher` keeps its own API).
+ *
+ * - Uncontrolled (default): `default-checked` sets the initial state and the
+ *   switch flips itself on click.
+ * - Controlled: once `checked` is set (attribute or property), clicks only
+ *   fire `anduin-switch-checked-change`; the consumer updates `checked`.
+ *
+ * Boolean attributes follow the design repo: `disabled="false"` is false.
+ * Inside an `<anduin-field>`, clicking its `<anduin-field-label>` toggles it.
+ */
+declare class AnduinSwitch extends LitElement {
+    static shadowRootOptions: {
+        delegatesFocus: boolean;
+        clonable?: boolean;
+        customElementRegistry?: CustomElementRegistry;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    static styles: CSSResult;
+    /** Controlled state. Setting it (attribute or property) switches the element to controlled mode. */
+    get checked(): boolean;
+    set checked(value: boolean);
+    private _checked;
+    /** Initial state in uncontrolled mode. */
+    defaultChecked: boolean;
+    disabled: boolean;
+    /** Accessible name for the switch (an enclosing field's label otherwise). */
+    label: string;
+    private _controlled;
+    private _uncontrolledChecked;
+    private _hasLabel;
+    private _fieldLabel;
+    private _field;
+    /** The state the switch currently shows. */
+    get isChecked(): boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** Toggles the switch as a click would. */
+    toggle(): void;
+    private _onFieldClick;
+    private _onClick;
+    private _onSlotChange;
+    render(): TemplateResult<1>;
+}
+
 declare class AnduinSwitcher extends LitElement {
     static styles: CSSResult;
     checked: boolean;
@@ -1687,6 +3184,8 @@ declare class AnduinTag extends LitElement {
     icon: string;
     /** Colors the icon in place of the variant's color: a palette name, or an ID marked with `uid:` */
     iconColor: TagIconColor | '';
+    /** Colors the icon from an ID, as the design repo's `icon-color-uid` does. Wins over `iconColor` */
+    iconColorUid: string;
     disabled: boolean;
     render(): TemplateResult<1>;
 }
@@ -2009,27 +3508,162 @@ declare class AnduinTooltipContent extends LitElement {
     render(): TemplateResult<1>;
 }
 
-declare class AnduinTooltipTrigger extends LitElement {
-    static styles: CSSResult;
+declare class AnduinTooltipTrigger extends LitElement {
+    static styles: CSSResult;
+    firstUpdated(): void;
+    render(): TemplateResult<1>;
+}
+
+/**
+ * `<anduin-truncated>` — the design repo's truncation wrapper.
+ *
+ * It truncates its single element child without introducing a layout box: the host and its shadow root are
+ * `display: contents`, so the child stays the flex / grid / inline item its parent lays out and keeps its own
+ * sizing. The truncation CSS is applied to the child through `::slotted(:only-child)`:
+ *
+ * - default: single-line ellipsis (`overflow: hidden; text-overflow: ellipsis; white-space: nowrap`)
+ * - `line-clamp="N"`: an N-line clamp (`display: -webkit-box; -webkit-line-clamp: N`). Non-positive or invalid
+ *   values fall back to one line.
+ *
+ * On pointer entry or keyboard focus it measures the child and, only when the content is actually clipped, shows
+ * the full value in an `anduin-tooltip` anchored to the child. The tooltip text is the `tooltip` attribute when
+ * present (even empty), otherwise the normalized text content. Inside an `anduin-tooltip-trigger` (across shadow
+ * boundaries) its own tooltip stays off so the outer tooltip wins. No `title` is added, and nothing is measured or
+ * rendered until the first interaction.
+ */
+declare class AnduinTruncated extends LitElement {
+    static styles: CSSResult;
+    /** Number of lines before clipping. Absent: single-line ellipsis. */
+    lineClamp: number | string | null;
+    /** Tooltip text override. Absent: the element's normalized text content. Read on interaction. */
+    tooltip: string | null;
+    private _tooltipRendered;
+    private _tooltipText;
+    private _describedTarget;
+    /** Bumped by every enter and leave, so a show that finishes rendering after the pointer left is dropped. */
+    private _requestId;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** The single element child the truncation applies to, or null when there is not exactly one. */
+    get target(): HTMLElement | null;
+    /** Whether the child's content is currently clipped. */
+    get isTruncated(): boolean;
+    private get _normalizedText();
+    private _isInsideTooltipTrigger;
+    private _onEnter;
+    private _onLeave;
+    private _onFocusOut;
+    private _onKeyDown;
+    private _hide;
+    /**
+     * The tooltip describes the element only when it says something the element does not already say: a tooltip that
+     * repeats the visible text is a magnifying glass, not a description.
+     */
+    private _describe;
+    private _clearDescription;
+    render(): TemplateResult<1>;
+}
+
+declare class AnduinWell extends LitElement {
+    static styles: CSSResult;
+    variant: string;
+    render(): TemplateResult<1>;
+}
+
+declare class AnduinWellClose extends LitElement {
+    static styles: CSSResult;
+    private onClick;
+    render(): TemplateResult<1>;
+}
+
+export declare const Autocomplete: ReactWebComponent<AnduinAutocomplete, {
+onValueChange: ValueEvent;
+onChoose: ValueEvent;
+onClose: ValueEvent<undefined>;
+}>;
+
+/** Field: before typed/pasted/dropped text lands — detail `{ value }` (the candidate). Cancelable: refuses it. */
+export declare const AUTOCOMPLETE_BEFORE_INPUT = "anduin-autocomplete-on-before-input";
+
+/** Field: focus left the text field — detail `{ value }` (the text). */
+export declare const AUTOCOMPLETE_BLUR = "anduin-autocomplete-on-blur";
+
+/** Root: the text changed (every keystroke, and once more with the label on a pick) — detail `{ value }` (the text). */
+export declare const AUTOCOMPLETE_CHANGE = "change";
+
+/** Root: a suggestion was picked (click or Enter) — detail `{ value }` (the item's `value`). Fires after `change`. */
+export declare const AUTOCOMPLETE_CHOOSE = "anduin-autocomplete-on-choose";
+
+/** Root: the list closed (pick, Escape, Tab, Enter, outside click). Does not bubble. */
+export declare const AUTOCOMPLETE_CLOSE = "anduin-autocomplete-on-close";
+
+/** Item: clicked — detail `{ value }`. Cancelable: `preventDefault()` keeps the text and the list open. */
+export declare const AUTOCOMPLETE_ITEM_SELECTED = "anduin-autocomplete-item-selected";
+
+/** Field: Enter with no suggestion highlighted — detail `{ value }`. Cancelable: cancelling claims the key. */
+export declare const AUTOCOMPLETE_SUBMIT = "anduin-autocomplete-on-submit";
+
+export declare const AutocompleteClear: ReactWebComponent<AnduinAutocompleteClear, {}>;
+
+export declare const AutocompleteContent: ReactWebComponent<AnduinAutocompleteContent, {}>;
+
+export declare const AutocompleteEmpty: ReactWebComponent<AnduinAutocompleteEmpty, {}>;
+
+/** Shared by `-input` and `-textarea`: size, status, disabled, open-on-focus, and the design events. */
+declare abstract class AutocompleteFieldBase extends PickerField {
+    static family: string;
+    disabled: boolean;
+    /** Open the list on every focus, not only when the field is empty. */
+    openOnFocus: boolean;
+    size: 'small' | 'default' | 'large';
+    /** `valid` | `invalid` | `warning` | `none` — border colour only. */
+    status: string;
+    protected _hasAdornment: boolean;
+    get isDisabled(): boolean;
+    get autocomplete(): AnduinAutocomplete | null;
     firstUpdated(): void;
-    render(): TemplateResult<1>;
+    updated(changed: PropertyValues<this>): void;
+    protected controlClasses(base: string): string;
+    protected wrapperClasses(): string;
+    protected _onSlotChange(e: Event): void;
+    protected _onBlur(): void;
+    /** Reports insertions as a cancelable candidate; cancelling refuses the insertion before the browser applies it. */
+    protected _onBeforeInput(e: InputEvent): void;
+    /** Enter with nothing highlighted: report `on-submit`; cancelling it claims the key. Returns whether it was claimed. */
+    protected submit(e: KeyboardEvent): boolean;
+    protected closeOnEscape(e: KeyboardEvent): boolean;
 }
 
-declare class AnduinWell extends LitElement {
-    static styles: CSSResult;
-    variant: string;
-    render(): TemplateResult<1>;
-}
+export declare const AutocompleteGroup: ReactWebComponent<AnduinAutocompleteGroup, {}>;
 
-declare class AnduinWellClose extends LitElement {
-    static styles: CSSResult;
-    private onClick;
-    render(): TemplateResult<1>;
-}
+export declare const AutocompleteInput: ReactWebComponent<AnduinAutocompleteInput, {
+onBlur: ValueEvent;
+onSubmit: ValueEvent;
+onBeforeInput: ValueEvent;
+}>;
+
+export declare const AutocompleteItem: ReactWebComponent<AnduinAutocompleteItem, {
+onSelect: ValueEvent;
+}>;
+
+export declare const AutocompleteLabel: ReactWebComponent<AnduinAutocompleteLabel, {}>;
+
+export declare const AutocompleteList: ReactWebComponent<AnduinAutocompleteList, {}>;
+
+export declare const AutocompleteSeparator: ReactWebComponent<AnduinAutocompleteSeparator, {}>;
+
+export declare const AutocompleteTextarea: ReactWebComponent<AnduinAutocompleteTextarea, {
+onBlur: ValueEvent;
+onSubmit: ValueEvent;
+onBeforeInput: ValueEvent;
+}>;
 
 export declare const Avatar: ReactWebComponent<AnduinAvatar, {}>;
 
-declare type AvatarShape = 'circle' | 'rounded';
+export declare const AvatarBlock: ReactWebComponent<AnduinAvatarBlock, {}>;
+
+/** `square` is the design repo's name for `rounded` (4px corners). */
+declare type AvatarShape = 'circle' | 'rounded' | 'square';
 
 declare type AvatarSize = 16 | 20 | 24 | 32;
 
@@ -2072,6 +3706,67 @@ onChange: string;
 
 export declare const CHECKBOX_CHANGE = "anduin-checkbox:change";
 
+declare const Clipboard_2: ReactWebComponent<AnduinClipboard, {}>;
+export { Clipboard_2 as Clipboard }
+
+export declare const ClipboardIndicator: ReactWebComponent<AnduinClipboardIndicator, {}>;
+
+declare type ClipboardIndicatorAppearance = 'plain' | 'text';
+
+/** Where a copy stands: requested-and-written, refused, or back at rest 2 seconds after the request. */
+declare type ClipboardStatus = 'idle' | 'copied' | 'failed';
+
+export declare const ClipboardTrigger: ReactWebComponent<AnduinClipboardTrigger, {}>;
+
+export declare const Collapsible: ReactWebComponent<AnduinCollapsible, {
+onOpenChange: EventName<CustomEvent<{
+value: boolean;
+}>>;
+}>;
+
+/**
+ * Fired on `<anduin-collapsible>` when the user toggles it (unless `disabled`).
+ * Detail: `{ value: boolean }` — the requested open state. Does not bubble, as
+ * in the design repo, so a nested collapsible never toggles its parent's handler.
+ */
+export declare const COLLAPSIBLE_OPEN_CHANGE = "anduin-collapsible-open-change";
+
+export declare const CollapsibleContent: ReactWebComponent<AnduinCollapsibleContent, {}>;
+
+declare type CollapsibleDirection = 'vertical' | 'horizontal';
+
+export declare const CollapsibleIcon: ReactWebComponent<AnduinCollapsibleIcon, {}>;
+
+export declare const CollapsibleTrigger: ReactWebComponent<AnduinCollapsibleTrigger, {}>;
+
+export declare const Combobox: ReactWebComponent<AnduinCombobox, {
+onValueChange: ValueEvent;
+}>;
+
+/** Fired by the root when the user picks an item — detail: `{ value }` (the item's `value`). */
+export declare const COMBOBOX_CHANGE = "change";
+
+/** Fired by an item when it is clicked — detail: `{ value }`. Cancelable: `preventDefault()` keeps the list open. */
+export declare const COMBOBOX_ITEM_SELECTED = "anduin-combobox-item-selected";
+
+export declare const ComboboxContent: ReactWebComponent<AnduinComboboxContent, {}>;
+
+export declare const ComboboxEmpty: ReactWebComponent<AnduinComboboxEmpty, {}>;
+
+export declare const ComboboxGroup: ReactWebComponent<AnduinComboboxGroup, {}>;
+
+export declare const ComboboxInput: ReactWebComponent<AnduinComboboxInput, {}>;
+
+export declare const ComboboxItem: ReactWebComponent<AnduinComboboxItem, {
+onSelect: ValueEvent;
+}>;
+
+export declare const ComboboxLabel: ReactWebComponent<AnduinComboboxLabel, {}>;
+
+export declare const ComboboxList: ReactWebComponent<AnduinComboboxList, {}>;
+
+export declare const ComboboxSeparator: ReactWebComponent<AnduinComboboxSeparator, {}>;
+
 /** Fired when every segment is filled. `event.detail` is the formatted date string. */
 export declare const DATE_INPUT_CHANGE = "anduin-date-input:change";
 
@@ -2108,8 +3803,58 @@ declare type DateRangePanelRole = 'start' | 'end';
 
 export declare const DateRangeStart: ReactWebComponent<AnduinDateRangeStart, {}>;
 
+/** The design repo's named sizes: small 20px, medium 24px, large 32px (default), extraLarge 40px. */
+declare type DesignAvatarSize = 'small' | 'medium' | 'large' | 'extraLarge';
+
+export declare const Dialog: ReactWebComponent<AnduinDialog, {
+onOpenChange: string;
+onOpen: string;
+onClose: string;
+}>;
+
+/** The dialog became hidden (either mode). `detail: { value: undefined }`. Does not bubble. */
+export declare const DIALOG_ON_CLOSE = "anduin-dialog-on-close";
+
+/** The dialog became visible (either mode). `detail: { value: undefined }`. Does not bubble. */
+export declare const DIALOG_ON_OPEN = "anduin-dialog-on-open";
+
+/** Controlled mode: the dialog asks to open or close. `detail: { value: boolean }`. Does not bubble. */
+export declare const DIALOG_OPEN_CHANGE = "anduin-dialog-open-change";
+
+export declare const DialogBody: ReactWebComponent<AnduinDialogBody, {}>;
+
+export declare const DialogClose: ReactWebComponent<AnduinDialogClose, {}>;
+
+export declare const DialogContent: ReactWebComponent<AnduinDialogContent, {}>;
+
+export declare const DialogDescription: ReactWebComponent<AnduinDialogDescription, {}>;
+
+export declare const DialogFooter: ReactWebComponent<AnduinDialogFooter, {}>;
+
+export declare const DialogHeader: ReactWebComponent<AnduinDialogHeader, {}>;
+
+declare type DialogHeight = 'fill';
+
+export declare const DialogOverlay: ReactWebComponent<AnduinDialogOverlay, {}>;
+
+/** Re-names the owning content whenever this element's text changes. */
+declare abstract class DialogTextElement extends LitElement {
+    private _observer?;
+    private _owner;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+
+export declare const DialogTitle: ReactWebComponent<AnduinDialogTitle, {}>;
+
+export declare const DialogTrigger: ReactWebComponent<AnduinDialogTrigger, {}>;
+
+declare type DialogWidth = 'small' | 'medium' | 'large' | 'extraLarge' | 'full' | 'fitContent';
+
 export declare const Divider: ReactWebComponent<AnduinDivider, {}>;
 
+declare type DockSide = 'top' | 'right' | 'bottom' | 'left';
+
 export declare const Dot: ReactWebComponent<AnduinDot, {}>;
 
 declare type DotVariant = 'gray' | 'success' | 'primary' | 'danger' | 'warning' | 'purple' | 'customAqua' | 'customBlue' | 'customBlueGreen' | 'customGreen' | 'customHotPink' | 'customIndigo' | 'customMagenta' | 'customOrange' | 'customPink' | 'customPurple' | 'customRed' | 'customYellow' | 'customYellowGreen' | 'customYellowOrange';
@@ -2205,11 +3950,81 @@ export declare const INPUT_CLEAR = "anduin-input:clear";
 
 export declare const LoadingState: ReactWebComponent<AnduinLoadingState, {}>;
 
-export declare const Menu: ReactWebComponent<AnduinMenu, {}>;
+export declare const Menu: ReactWebComponent<AnduinMenu, {
+onOpenChange: string;
+}>;
 
+/** Old API: fired by `anduin-menu-item` on every click (no detail). */
 export declare const MENU_ITEM_CLICK = "anduin-menu-item:click";
 
-export declare const MenuItem: ReactWebComponent<AnduinMenuItem, {}>;
+/**
+ * Design API: an item was chosen (click, Enter, Space). `detail` is `{ value: true }`. Cancelable — call
+ * `preventDefault()` to keep the menu open (checkbox-style items, loading items).
+ */
+export declare const MENU_ITEM_SELECTED = "anduin-menu-item-selected";
+
+/** Design API: the menu asks to open (`detail.value === true`) or close. Fired before `open` changes. */
+export declare const MENU_OPEN_CHANGE = "anduin-menu-open-change";
+
+export declare const MenuContent: ReactWebComponent<AnduinMenuContent, {}>;
+
+export declare const MenuGroup: ReactWebComponent<AnduinMenuGroup, {}>;
+
+export declare const MenuItem: ReactWebComponent<AnduinMenuItem, {
+onSelect: string;
+onItemClick: string;
+}>;
+
+export declare const MenuLabel: ReactWebComponent<AnduinMenuLabel, {}>;
+
+export declare const MenuSeparator: ReactWebComponent<AnduinMenuSeparator, {}>;
+
+export declare const MenuSub: ReactWebComponent<AnduinMenuSub, {}>;
+
+export declare const MenuSubContent: ReactWebComponent<AnduinMenuSubContent, {}>;
+
+export declare const MenuSubTrigger: ReactWebComponent<AnduinMenuSubTrigger, {}>;
+
+/**
+ * Keyboard navigation shared by `anduin-menu-content` and `anduin-menu-sub-content`: ArrowUp/Down (wrapping),
+ * Home/End and typeahead over the items this surface owns (not those of a nested sub-menu).
+ */
+declare abstract class MenuSurface extends LitElement {
+    protected _popup: HTMLElement;
+    protected _active: boolean;
+    protected _shown: boolean;
+    private _stopTracking;
+    private _typed;
+    private _typedAt;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** Enabled items and sub-triggers that belong to this surface, in DOM order. */
+    items(): HTMLElement[];
+    /** Focuses the first or last enabled item. */
+    focusEdge(which: 'first' | 'last'): void;
+    /* Excluded from this release type: setActive */
+    protected _sync(): void;
+    protected _show(): void;
+    protected _hide(): void;
+    protected _beforeShow(): void;
+    protected abstract _anchor(): {
+        ref: Element;
+        placement: PopupPlacement;
+        dx: number;
+        dy: number;
+    } | null;
+    private _position;
+    protected _onKeyDown: (e: KeyboardEvent) => void;
+    /** Keys a surface handles itself before list navigation (sub-menus: ArrowLeft / Escape). */
+    protected _handleOwnKey(_e: KeyboardEvent): boolean;
+    /**
+     * Characters typed within half a second spell one word; the same character repeated cycles through the items
+     * starting with it. Matching ignores case and wraps.
+     */
+    private _typeahead;
+}
+
+export declare const MenuTrigger: ReactWebComponent<AnduinMenuTrigger, {}>;
 
 export declare const Modal: ReactWebComponent<AnduinModal, {
 onClose: string;
@@ -2241,14 +4056,35 @@ export declare const Navigation: ReactWebComponent<AnduinNavigation, {
 onChange: string;
 }>;
 
+/** Fired when a user activates an item, even the selected one. `detail: { value }` is the item's `value`. */
+export declare const NAVIGATION_BAR_VALUE_CHANGE = "anduin-navigation-bar-value-change";
+
 export declare const NAVIGATION_CHANGE = "anduin-navigation:change";
 
 declare type NavigationAlignment = 'left' | 'center' | 'right';
 
+export declare const NavigationBar: ReactWebComponent<AnduinNavigationBar, {
+onValueChange: EventName<CustomEvent<{
+value: string;
+}>>;
+}>;
+
+export declare const NavigationBarItem: ReactWebComponent<AnduinNavigationBarItem, {}>;
+
 export declare const NavigationItem: ReactWebComponent<AnduinNavigationItem, {}>;
 
 declare type NavigationTheme = 'light' | 'dark';
 
+export declare const NonIdealState: ReactWebComponent<AnduinNonIdealState, {}>;
+
+export declare const NonIdealStateAction: ReactWebComponent<AnduinNonIdealStateAction, {}>;
+
+export declare const NonIdealStateDescription: ReactWebComponent<AnduinNonIdealStateDescription, {}>;
+
+export declare const NonIdealStateIcon: ReactWebComponent<AnduinNonIdealStateIcon, {}>;
+
+export declare const NonIdealStateTitle: ReactWebComponent<AnduinNonIdealStateTitle, {}>;
+
 export declare const Pagination: ReactWebComponent<AnduinPagination, {
 onValueChange: string;
 }>;
@@ -2260,15 +4096,271 @@ export declare const PaginationFirstPage: ReactWebComponent<AnduinPaginationFirs
 
 export declare const PaginationLastPage: ReactWebComponent<AnduinPaginationLastPage, {}>;
 
+declare class PickerContent extends LitElement {
+    static family: string;
+    static styles: CSSResult[];
+    /** Fixed panel width in px. Unset: the panel shrink-wraps its items (min 160px). */
+    width: number | null;
+    private _visible;
+    private _natural;
+    get visible(): boolean;
+    private get _panel();
+    private get _inner();
+    /** Shows/hides the panel; `remeasure` re-reads its natural size (contents changed). */
+    setVisible(visible: boolean, remeasure?: boolean): void;
+    /** Places the panel beside `anchor`, capping its height to the room on the side it opens on. */
+    reposition(anchor: DOMRect, placement: string, remeasure?: boolean): void;
+    render(): TemplateResult<1>;
+}
+
+declare class PickerEmpty extends LitElement {
+    static family: string;
+    static styles: CSSResult;
+    connectedCallback(): void;
+    render(): TemplateResult<1>;
+}
+
+declare abstract class PickerField extends LitElement {
+    static family: string;
+    placeholder: string;
+    /** Accessible name (else `aria-label`, an enclosing field's label, then the placeholder). */
+    label: string;
+    /** Custom match predicate: `({ query, value, label }) => boolean`, consulted for a non-empty query. */
+    filter: PickerFilter | null;
+    protected _text: string;
+    get root(): PickerRoot | null;
+    /** The native `<input>` / `<textarea>` inside. */
+    get control(): HTMLInputElement | HTMLTextAreaElement | null;
+    get isDisabled(): boolean;
+    /** The text in the field. */
+    get text(): string;
+    set text(value: string);
+    focusField(): void;
+    protected accessibleName(): string;
+    /** Writes the popup state onto the native field (the element with `role="combobox"`). */
+    syncAria(expanded: boolean, list: HTMLElement | null, active: HTMLElement | null): void;
+    protected _onFocus(): void;
+    protected _onInput(e: Event): void;
+}
+
+declare type PickerFilter = (item: PickerFilterItem) => boolean;
+
+/**
+ * Shared internals of the design repo's two text-field pickers:
+ *
+ * - `anduin-combobox` — pick ONE OF the listed items; the typed text is only a filter, and the
+ *   field reverts to the chosen item's label when the list closes.
+ * - `anduin-autocomplete` — the value IS the typed text; the list is a shortcut for typing.
+ *
+ * Both are compound: a root coordinates light-DOM parts (`-input`, `-content`, `-list`, `-item`,
+ * `-group`, `-label`, `-separator`, `-empty`) that find their root with `closest()`. Every part
+ * class here is family-agnostic; a family subclass sets `static family` to its root tag name.
+ *
+ * The floating panel reuses `anduin-suggestion`'s shell and positioning (`popupPanelStyles`,
+ * `positionPopup`).
+ */
+/** What a custom `filter` predicate receives (design: `ItemFilter`). */
+declare interface PickerFilterItem {
+    query: string;
+    value: string;
+    label: string;
+}
+
+declare class PickerGroup extends LitElement {
+    static family: string;
+    static styles: CSSResult;
+    connectedCallback(): void;
+    render(): TemplateResult<1>;
+}
+
+declare class PickerItem extends LitElement {
+    static family: string;
+    static styles: CSSResultGroup;
+    value: string;
+    /** Text shown in the field and matched by the filter (default: the item's text). */
+    label: string | null;
+    disabled: boolean;
+    private _highlighted;
+    get root(): PickerRoot | null;
+    get highlighted(): boolean;
+    set highlighted(value: boolean);
+    /** The item's display label: `label`, else its text (without a `description` slot). */
+    get labelText(): string;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changed: PropertyValues<this>): void;
+    private _onPointer;
+    private _onMouseDown;
+    private _onClick;
+    /** Leading part of the row (autocomplete: `start-icon`). */
+    protected renderStart(): unknown;
+    /** Trailing part of the row (combobox: the check). */
+    protected renderEnd(): unknown;
+    protected renderContent(): unknown;
+    protected rowClass(): string;
+    render(): TemplateResult<1>;
+}
+
+/** One entry of a list's data-driven `items` property. */
+declare interface PickerItemData {
+    value: string;
+    label?: string;
+    description?: string;
+    disabled?: boolean;
+}
+
+declare class PickerLabel extends LitElement {
+    static family: string;
+    static styles: CSSResult;
+    render(): TemplateResult<1>;
+}
+
+declare class PickerList extends LitElement {
+    static family: string;
+    static styles: CSSResult;
+    /** Cap on the scrolling list: any CSS length (`400px`, `50vh`, `24rem`) or `none`. */
+    maxHeight: string | null;
+    /**
+     * Data-driven items (`{ value, label?, description?, disabled? }`), rendered as items in this
+     * list's light DOM. Not virtualised: every item is materialised.
+     */
+    items: PickerItemData[] | null;
+    connectedCallback(): void;
+    updated(changed: PropertyValues<this>): void;
+    private _renderItems;
+    render(): TemplateResult<1>;
+}
+
+declare abstract class PickerRoot extends LitElement {
+    static family: string;
+    static styles: CSSResult;
+    /** The value. Combobox: the chosen item's `value`. Autocomplete: the text in the field. */
+    value: string;
+    /** Where the panel opens: `bottom-start` (default), `bottom-end`, `top-start`, … */
+    placement: string;
+    /** Row height in px for every item (sets `--<family>-item-height`). */
+    itemHeight: string | null;
+    protected _open: boolean;
+    protected _highlighted: PickerItem | null;
+    private _ignorePointer;
+    private _raf;
+    private _anchorKey;
+    /** Whether the list is open. */
+    get open(): boolean;
+    get family(): string;
+    /** Descendants matching `selector` that belong to this root (not to a nested picker). */
+    protected own<T extends Element>(selector: string): T[];
+    get field(): PickerField | null;
+    get content(): PickerContent | null;
+    get list(): PickerList | null;
+    /** Every item, in DOM order. */
+    items(): PickerItem[];
+    protected get emptyElement(): HTMLElement | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changed: PropertyValues<this>): void;
+    render(): TemplateResult<1>;
+    /** The query the list is filtered by when it opens. */
+    protected abstract openQuery(): string;
+    /** Whether the empty element shows for this result. */
+    protected abstract emptyVisible(query: string, nothingMatched: boolean): boolean;
+    /** Whether the panel shows at all for this result. */
+    protected abstract panelVisible(nothingMatched: boolean): boolean;
+    /** An item was clicked (and the consumer did not cancel `-item-selected`). */
+    protected abstract onItemChosen(value: string): void;
+    /** Text field typed into. */
+    abstract fieldInput(text: string): void;
+    /** Text field focused. */
+    abstract fieldFocus(): void;
+    /** Called after the list opened (no keyboard highlight requested). */
+    protected onOpened(): void;
+    /** Called after the list closed. */
+    protected onClosed(): void;
+    /** Opens the list. `highlight` picks the first/last navigable item, as ArrowDown/ArrowUp do. */
+    openPanel(highlight?: 'first' | 'last'): void;
+    closePanel(): void;
+    /** Whether `item` matches a non-empty `query`: the field's `filter`, else a case-insensitive label match. */
+    protected itemMatches(query: string, item: PickerItem): boolean;
+    /** Hides the items that do not match `query`, collapses emptied groups and their separators. */
+    protected applyFilter(query: string): number;
+    private _updateStructure;
+    get highlighted(): PickerItem | null;
+    /** Visible, enabled items: the ones the arrow keys move through. */
+    protected navigable(): PickerItem[];
+    protected setHighlight(item: PickerItem, scroll?: boolean): void;
+    clearHighlight(): void;
+    highlightFirst(): void;
+    highlightLast(): void;
+    /** ArrowDown (+1) / ArrowUp (-1) while open, wrapping, skipping disabled and filtered-out items. */
+    moveHighlight(direction: 1 | -1): void;
+    /** Pointer over an item. Ignored until the pointer really moves after the list opens or re-filters. */
+    itemHovered(item: PickerItem): void;
+    protected ignorePointerUntilMove(): void;
+    protected syncField(): void;
+    /** The label an item shows in the field: its `label`, else its text. */
+    protected labelFor(value: string): string;
+    private _onItemSelected;
+    private _onDocumentPointerDown;
+    private _onDocumentPointerMove;
+    /** The element the panel is placed against: the field host. */
+    protected get anchor(): Element | null;
+    private _startLoop;
+    private _stopLoop;
+    /** Re-measures and places the panel now (after its contents changed). */
+    reposition(): void;
+}
+
+declare class PickerSeparator extends LitElement {
+    static family: string;
+    static styles: CSSResult;
+    connectedCallback(): void;
+    render(): symbol;
+}
+
 export declare const Popover: ReactWebComponent<AnduinPopover, {
 onOpenChange: string;
+onOpenChangeRequest: string;
+onOpen: string;
+onClose: string;
 }>;
 
+/**
+ * Design API: the popover asks to open (`detail.value === true`) or close — trigger click, Escape, outside click,
+ * a close part. Fired before `open` changes; set `open` back from the handler to keep it controlled.
+ */
+export declare const POPOVER_DESIGN_OPEN_CHANGE = "anduin-popover-open-change";
+
+/** Design API: the popover was hidden. `detail` is `{ value: undefined }`. */
+export declare const POPOVER_ON_CLOSE = "anduin-popover-on-close";
+
+/** Design API: the popover became visible. `detail` is `{ value: undefined }`. */
+export declare const POPOVER_ON_OPEN = "anduin-popover-on-open";
+
 /** Fired whenever `open` changes, including self-initiated toggles and outside clicks. `event.detail` is the new state. */
 export declare const POPOVER_OPEN_CHANGE = "anduin-popover:open-change";
 
 export declare const PopoverClose: ReactWebComponent<AnduinPopoverClose, {}>;
 
+export declare const PopoverContent: ReactWebComponent<AnduinPopoverContent, {}>;
+
+export declare const PopoverTitle: ReactWebComponent<AnduinPopoverTitle, {}>;
+
+export declare const PopoverTrigger: ReactWebComponent<AnduinPopoverTrigger, {}>;
+
+declare type PopupAlign = 'start' | 'center' | 'end';
+
+declare type PopupPlacement = `${PopupSide}-${PopupAlign}`;
+
+/** The design repo's 12 placements (`PlacementTypes.Placement`); `top`/`bottom`/`left`/`right` mean `-center`. */
+declare type PopupPlacement_2 = 'top-center' | 'top-start' | 'top-end' | 'bottom-center' | 'bottom-start' | 'bottom-end' | 'left-center' | 'left-start' | 'left-end' | 'right-center' | 'right-start' | 'right-end' | 'top' | 'bottom' | 'left' | 'right';
+
+/**
+ * Shared machinery for the design-API popups (`anduin-popover-content`, `anduin-menu-content`,
+ * `anduin-menu-sub-content`): placement, frame-by-frame tracking, the Escape stack and focus helpers.
+ * Ported from the design repo's `PopupPlacement`, `PopupPositionTracker`, `OverlayStack` and `FocusUtils`.
+ */
+declare type PopupSide = 'top' | 'bottom' | 'left' | 'right';
+
 export declare const Progress: ReactWebComponent<AnduinProgress, {}>;
 
 export declare const Radio: ReactWebComponent<AnduinRadio, {
@@ -2298,6 +4390,125 @@ export declare const RESIZE_EVENT = "anduin-resizable:resize";
 
 declare type ResizeOrientation = 'horizontal' | 'vertical';
 
+export declare const Select: ReactWebComponent<AnduinSelect, {
+onValueChange: EventName<CustomEvent<{
+value: string;
+}>>;
+onClose: string;
+}>;
+
+/**
+ * Fired on `<anduin-select>` when the user picks a value (or clears it) — detail: `{ value: string }`.
+ * The design repo's name, used verbatim: it is the plain `change`.
+ */
+export declare const SELECT_CHANGE = "change";
+
+/** Fired on `<anduin-select>` whenever the dropdown closes (selection, outside click, Escape, trigger). Does not bubble. */
+export declare const SELECT_CLOSE = "anduin-select-on-close";
+
+/**
+ * Fired on the `<anduin-select-item>` the user picks (click, or Enter/Space on the highlighted one) — detail:
+ * `{ value: string }`, bubbles, **cancelable**: `preventDefault()` keeps the dropdown open and leaves the value alone.
+ */
+export declare const SELECT_ITEM_SELECTED = "anduin-select-item-selected";
+
+export declare const SelectClear: ReactWebComponent<AnduinSelectClear, {}>;
+
+export declare const SelectContent: ReactWebComponent<AnduinSelectContent, {}>;
+
+export declare const SelectEmpty: ReactWebComponent<AnduinSelectEmpty, {}>;
+
+export declare const SelectFooter: ReactWebComponent<AnduinSelectFooter, {}>;
+
+export declare const SelectGroup: ReactWebComponent<AnduinSelectGroup, {}>;
+
+export declare const SelectHeader: ReactWebComponent<AnduinSelectHeader, {}>;
+
+export declare const SelectInput: ReactWebComponent<AnduinSelectInput, {}>;
+
+declare type SelectInputSize = 'small' | 'default' | 'large';
+
+export declare const SelectItem: ReactWebComponent<AnduinSelectItem, {
+onClick: EventName<CustomEvent<{
+value: string;
+}>>;
+}>;
+
+/** Return whether the item stays visible. Replaces the default case-insensitive substring match on the label. */
+declare type SelectItemFilter = (item: SelectItemMatch) => boolean;
+
+/** What a custom `filter` / `rank` on `<anduin-select-input>` is asked about, once per item per non-empty query. */
+declare interface SelectItemMatch {
+    query: string;
+    value: string;
+    label: string;
+}
+
+/** Return `null`/`undefined` to hide the item, or a score: higher scores sort first within their group. */
+declare type SelectItemRank = (item: SelectItemMatch) => number | null | undefined;
+
+declare type SelectItemSize = 'medium' | 'free';
+
+export declare const SelectLabel: ReactWebComponent<AnduinSelectLabel, {}>;
+
+export declare const SelectList: ReactWebComponent<AnduinSelectList, {}>;
+
+declare type SelectPlacement = PopupPlacement_2;
+
+export declare const SelectSelectedLabel: ReactWebComponent<AnduinSelectSelectedLabel, {}>;
+
+export declare const SelectSeparator: ReactWebComponent<AnduinSelectSeparator, {}>;
+
+export declare const SelectTrigger: ReactWebComponent<AnduinSelectTrigger, {}>;
+
+export declare const Sheet: ReactWebComponent<AnduinSheet, {
+onOpenChange: string;
+onOpen: string;
+onClose: string;
+}>;
+
+/** Fired by `anduin-sheet-content` after a built-in dock toggle flips its `dock` — detail `{ value: boolean }` (now docked). */
+export declare const SHEET_DOCK_CHANGE = "anduin-sheet-dock-change";
+
+/** Fired by `anduin-sheet` once it closes (both modes). Stops at the sheet element. */
+export declare const SHEET_ON_CLOSE = "anduin-sheet-on-close";
+
+/** Fired by `anduin-sheet` once it opens (both modes). Stops at the sheet element. */
+export declare const SHEET_ON_OPEN = "anduin-sheet-on-open";
+
+/** Fired by `anduin-sheet-content` when the user resizes it — detail `{ value: number }`, the new size in px. */
+export declare const SHEET_ON_RESIZE = "anduin-sheet-on-resize";
+
+/** Fired by `anduin-sheet` in controlled mode when it wants to open or close — detail `{ value: boolean }`. Does not bubble. */
+export declare const SHEET_OPEN_CHANGE = "anduin-sheet-open-change";
+
+export declare const SheetClose: ReactWebComponent<AnduinSheetClose, {}>;
+
+export declare const SheetContent: ReactWebComponent<AnduinSheetContent, {
+onDockChange: string;
+onResize: string;
+}>;
+
+export declare const SheetDescription: ReactWebComponent<AnduinSheetDescription, {}>;
+
+export declare const SheetDockToggle: ReactWebComponent<AnduinSheetDockToggle, {}>;
+
+export declare const SheetDockToggleOff: ReactWebComponent<AnduinSheetDockToggleOff, {}>;
+
+export declare const SheetDockToggleOn: ReactWebComponent<AnduinSheetDockToggleOn, {}>;
+
+export declare const SheetFooter: ReactWebComponent<AnduinSheetFooter, {}>;
+
+export declare const SheetHeader: ReactWebComponent<AnduinSheetHeader, {}>;
+
+declare type SheetSide = DockSide;
+
+export declare const SheetTitle: ReactWebComponent<AnduinSheetTitle, {}>;
+
+export declare const SheetTrigger: ReactWebComponent<AnduinSheetTrigger, {}>;
+
+declare type SheetWidth = 'small' | 'medium' | 'large' | 'extraLarge' | 'fitContent' | (string & {});
+
 export declare const Sidebar: ReactWebComponent<AnduinSidebar, {}>;
 
 /**
@@ -2358,6 +4569,15 @@ declare interface SuggestionItem {
     icon?: string;
 }
 
+export declare const Switch: ReactWebComponent<AnduinSwitch, {
+onCheckedChange: EventName<CustomEvent<{
+value: boolean;
+}>>;
+}>;
+
+/** Fired when the user toggles the switch — detail: `{ value: boolean }` (the requested state). */
+export declare const SWITCH_CHECKED_CHANGE = "anduin-switch-checked-change";
+
 export declare const Switcher: ReactWebComponent<AnduinSwitcher, {
 onChange: string;
 }>;
@@ -2740,6 +4960,12 @@ export declare const TooltipContent: ReactWebComponent<AnduinTooltipContent, {}>
 
 export declare const TooltipTrigger: ReactWebComponent<AnduinTooltipTrigger, {}>;
 
+export declare const Truncated: ReactWebComponent<AnduinTruncated, {}>;
+
+declare type ValueEvent<T = string> = EventName<CustomEvent<{
+    value: T;
+}>>;
+
 export declare const Well: ReactWebComponent<AnduinWell, {}>;
 
 export declare const WELL_CLOSE_CLICK = "anduin-well-close:click";