@radix-ng/primitives 1.0.0-beta.2 → 1.0.0-beta.3

package/types/radix-ng-primitives-autocomplete.d.ts

@@ -0,0 +1,596 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+import * as i1 from '@radix-ng/primitives/combobox';
+import { ComboboxItemHighlightedDetails, ComboboxItemRef, ComboboxHighlightReason } from '@radix-ng/primitives/combobox';
+export { ComboboxHighlightReason as AutocompleteHighlightReason, ComboboxItemHighlightedDetails as AutocompleteItemHighlightedDetails } from '@radix-ng/primitives/combobox';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { AcceptableValue, Direction, BooleanInput, ItemValueComparator } from '@radix-ng/primitives/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i1$1 from '@radix-ng/primitives/popper';
+import * as _radix_ng_primitives_autocomplete from '@radix-ng/primitives/autocomplete';
+import * as i2 from '@radix-ng/primitives/dismissable-layer';
+
+/**
+ * Optional positioning anchor for the popup. Put it on the element the popup should align to — for
+ * example a wrapper that holds the input plus an icon/clear button. When present it takes precedence
+ * over the input. Reuses the combobox anchor behavior.
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteAnchor {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteAnchor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteAnchor, "[rdxAutocompleteAnchor]", ["rdxAutocompleteAnchor"], {}, {}, never, never, true, [{ directive: typeof i1.RdxComboboxAnchor; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Autocomplete filtering / inline-completion behavior, mirroring Base UI's `mode`:
+ * - `'list'` (default): items are filtered by the query; the input text never changes from the active item.
+ * - `'both'`: items are filtered **and** the input is inline-completed from the active item.
+ * - `'inline'`: items are static (not filtered) but the input is inline-completed from the active item.
+ * - `'none'`: items are static and the input is never changed from the active item.
+ */
+type AutocompleteMode = 'list' | 'both' | 'inline' | 'none';
+/**
+ * A custom filter predicate. Receives the item's text, the query, and the item's value (the object
+ * for object items) so a filter can match across multiple fields — e.g. fuzzy/multi-key matching.
+ */
+type AutocompleteFilter = (itemText: string, query: string, itemValue: AcceptableValue) => boolean;
+/** Why the input value changed, mirroring Base UI's `onValueChange` details. */
+type AutocompleteChangeReason = 'input-change' | 'item-press' | 'input-clear' | 'none';
+/** Payload of {@link RdxAutocompleteRoot.onValueChange}: the new value and why it changed. */
+interface AutocompleteValueChangeDetails {
+    /** The new input value. */
+    value: string;
+    /** What caused the change (e.g. skip `'item-press'` to avoid overwriting an external value). */
+    reason: AutocompleteChangeReason;
+}
+
+/**
+ * Root of an Autocomplete — a text input with a filtered list of suggestions. Built on the combobox
+ * engine with `selectionMode: 'none'`, so its value **is** the input string: typing, selecting an
+ * item, or clearing all change a single string value. Owns input text, open state, filtering, inline
+ * completion, and highlight-model navigation, and provides them to the combobox parts. Implements
+ * `ControlValueAccessor` (the form value is the input string).
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteRoot implements ControlValueAccessor {
+    private readonly injector;
+    /** The input text. This is the form value (controlled / uncontrolled via {@link defaultValue}). */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Initial input text when uncontrolled. */
+    readonly defaultValue: _angular_core.InputSignal<string | undefined>;
+    /** Whether the popup is open. */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** Initial open state when uncontrolled. */
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Filtering / inline-completion behavior. See {@link AutocompleteMode}. */
+    readonly mode: _angular_core.InputSignal<AutocompleteMode>;
+    /** Text direction. */
+    readonly dir: _angular_core.InputSignal<Direction>;
+    /** Whether the autocomplete is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the autocomplete is read-only. */
+    readonly readOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether a value is required (for forms). */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether keyboard navigation wraps at the list boundaries. */
+    readonly loopFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Auto-highlight behavior (matches Base UI):
+     * - `false` (default): never auto-highlight;
+     * - `true` (also the bare `autoHighlight` attribute): highlight the first match as the query changes;
+     * - `'always'`: keep the first navigable item highlighted whenever the popup is open.
+     */
+    readonly autoHighlight: _angular_core.InputSignalWithTransform<boolean | "always", BooleanInput>;
+    /** Resolved auto-highlight mode. */
+    readonly autoHighlightMode: _angular_core.Signal<"input-change" | "always" | "off">;
+    /**
+     * Whether moving the pointer over an item highlights it. `true` (default) paints `data-highlighted`
+     * on hover; `false` suppresses hover-driven highlight entirely, letting CSS `:hover` stay distinct
+     * from the `data-highlighted` (keyboard) state. Clicking an item still selects it.
+     */
+    readonly highlightItemOnHover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether a pointer-driven highlight is kept when the cursor leaves the list. `false` (default)
+     * clears the highlight on pointer-leave; `true` retains the last hovered item highlighted. Keyboard
+     * navigation and auto-highlight are unaffected.
+     */
+    readonly keepHighlight: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether clicking the input opens the popup. Defaults to `false` (Base UI default). */
+    readonly openOnInputClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the popup is modal: locks page scroll and makes outside content inert while open. */
+    readonly modal: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether selecting an item requests submit of the closest form. */
+    readonly submitOnItemClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the list is laid out as a 2D grid (enables row/column arrow navigation). */
+    readonly grid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Filter applied to items against the input query (only when {@link mode} is `'list'` / `'both'`).
+     * - `undefined` (default): locale-aware "contains" via {@link useFilter};
+     * - a function: custom matching;
+     * - `null`: built-in filtering disabled (the consumer controls which items exist).
+     */
+    readonly filter: _angular_core.InputSignal<AutocompleteFilter | null | undefined>;
+    /** Maximum number of matching items to show. `-1` (default) means no limit. */
+    readonly limit: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * The full set of item values, used as the source of truth for filtering and navigation in
+     * {@link virtualized} mode (where only a window of `RdxAutocompleteItem` is mounted).
+     */
+    readonly items: _angular_core.InputSignal<readonly AcceptableValue[] | undefined>;
+    /** Whether the list is externally virtualized (navigation runs over {@link items} by index). */
+    readonly virtualized: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** How item values are compared for equality (function or object key). */
+    readonly by: _angular_core.InputSignal<ItemValueComparator<AcceptableValue> | undefined>;
+    /** Converts an item value to its string label (filter text + input text on selection). */
+    readonly itemToStringValue: _angular_core.InputSignal<((value: AcceptableValue) => string) | undefined>;
+    /** Emits when the input value changes (typing, selection, or clear), with the reason. */
+    readonly onValueChange: _angular_core.OutputEmitterRef<AutocompleteValueChangeDetails>;
+    /** Emits when the popup opens or closes. */
+    readonly onOpenChange: _angular_core.OutputEmitterRef<boolean>;
+    /** Emits as the highlight moves, with the item's value, its index in {@link filteredItems}, and the reason. */
+    readonly onItemHighlighted: _angular_core.OutputEmitterRef<ComboboxItemHighlightedDetails>;
+    /** Emits after the open/close transition (including any exit animation) finishes. */
+    readonly onOpenChangeComplete: _angular_core.OutputEmitterRef<boolean>;
+    private readonly transition;
+    /** Open/close transition phase, for `data-starting-style` / `data-ending-style`. */
+    readonly transitionStatus: _angular_core.Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
+    /** Registers the popup element whose animation determines transition completion. */
+    readonly registerTransitionElement: (element: HTMLElement) => () => void;
+    readonly listId: string;
+    readonly labelId: _angular_core.WritableSignal<string | undefined>;
+    readonly inputElement: _angular_core.WritableSignal<HTMLInputElement | null>;
+    /** Constant signals exposed to the combobox context (autocomplete is always single-value). */
+    readonly alwaysFalse: _angular_core.WritableSignal<boolean>;
+    readonly noneMode: _angular_core.WritableSignal<"none">;
+    private readonly cvaDisabled;
+    readonly disabledState: _angular_core.Signal<boolean>;
+    readonly requiredState: _angular_core.Signal<boolean>;
+    private readonly defaultFilter;
+    /** Whether built-in filtering applies in the current mode. */
+    private readonly filteringMode;
+    /** Whether inline completion applies in the current mode. */
+    readonly inlineMode: _angular_core.Signal<boolean>;
+    /**
+     * Whether the input text is a fresh user query rather than a committed selection's label. While
+     * `false` (just opened, or showing a committed selection), the list is unfiltered so the user can
+     * browse; it flips `true` on the first keystroke.
+     */
+    private readonly typed;
+    /** The text the user actually typed, used as the filter query. */
+    readonly query: _angular_core.Signal<string>;
+    /** Transient inline-completion preview (the active item's label), or `null`. */
+    readonly inlinePreview: _angular_core.WritableSignal<string | null>;
+    /** What the input element displays: the inline preview if any, else the committed value. */
+    readonly displayValue: _angular_core.Signal<string>;
+    /** Suppresses inline completion for the current edit (set while a delete key is pressed). */
+    private suppressInline;
+    private readonly _items;
+    /** Registered items, sorted into DOM order. */
+    readonly orderedItems: _angular_core.Signal<ComboboxItemRef[]>;
+    /** Matching items in DOM order, capped at `limit`. The set of items the list shows. */
+    readonly visibleItems: _angular_core.Signal<ComboboxItemRef[]>;
+    private readonly visibleSet;
+    /** The filtered item values an external virtualizer should render. */
+    readonly filteredItems: _angular_core.Signal<readonly AcceptableValue[]>;
+    readonly visibleCount: _angular_core.Signal<number>;
+    readonly highlight: _radix_ng_primitives_core.ListHighlight<ComboboxItemRef>;
+    readonly highlightedItem: _angular_core.Signal<ComboboxItemRef | null>;
+    /** Highlighted index into {@link filteredItems} in virtualized mode (`-1` when cleared). */
+    readonly highlightedIndex: _angular_core.WritableSignal<number>;
+    /** Why the highlight last moved; read when emitting {@link onItemHighlighted}. */
+    private readonly highlightReason;
+    readonly activeId: _angular_core.Signal<string | undefined>;
+    /**
+     * What to highlight once the list has mounted (items register asynchronously after opening):
+     * an end edge, or `'first-match'` (the first item whose label starts with the query — used by
+     * auto-highlight so inline completion lands on a real prefix match even when the list is static).
+     */
+    private readonly pendingHighlightEdge;
+    private onChange?;
+    private onTouched?;
+    constructor();
+    private recomputeInlinePreview;
+    setSuppressInline(value: boolean): void;
+    /** Opens the popup for browsing (resets the query to "pristine" and selects the input text). */
+    openForBrowse(): void;
+    /** Opens the popup and highlights the given edge once the list mounts. */
+    openAndHighlight(edge: 'first' | 'last'): void;
+    /** Whether the item matches the active query (ignores the `limit` cap). */
+    private matchesFilter;
+    /** Whether the item is shown in the list (matches the query and is within `limit`). */
+    isVisible(item: ComboboxItemRef): boolean;
+    /** The first visible, navigable item whose label starts with the query (for inline completion). */
+    private firstMatchItem;
+    /** The first visible, navigable item (auto-highlight fallback when no prefix match exists). */
+    private firstVisibleNavigable;
+    /** Resolves a pending edge to a virtualized index. */
+    private resolveVirtualizedEdge;
+    private keyboardActive;
+    isKeyboardActive(): boolean;
+    setKeyboardActive(value: boolean): void;
+    /** Whether the item's value/label matches the current input value (combobox context contract). */
+    isSelectedValue(value: AcceptableValue): boolean;
+    registerItem(item: ComboboxItemRef): void;
+    unregisterItem(item: ComboboxItemRef): void;
+    setOpen(open: boolean): void;
+    closePopup(revert?: boolean): void;
+    /** Updates the input text from user typing (marks it a fresh query, emits change). */
+    setQuery(value: string): void;
+    /** Selects all input text so the next keystroke replaces a committed label. */
+    selectInputText(): void;
+    labelFor(value: AcceptableValue): string;
+    /** Label text for a raw item value (virtualized mode, no DOM element to read from). */
+    private textFor;
+    /** Deterministic id for the item at `index` in virtualized mode (matches `aria-activedescendant`). */
+    itemId(index: number): string;
+    handleSelect(item: ComboboxItemRef): void;
+    /** Selects the filtered item at `index` (virtualized mode). */
+    selectIndex(index: number): void;
+    /** Commits a selection: the input value becomes the item's label, the popup closes. */
+    private commitSelection;
+    private maybeSubmit;
+    selectHighlighted(): void;
+    moveDown(): void;
+    moveUp(): void;
+    /** Grid: move to the next cell in DOM order. Non-grid: no-op (caret movement). */
+    moveRight(): void;
+    moveLeft(): void;
+    highlightFirst(reason?: ComboboxHighlightReason): void;
+    highlightLast(reason?: ComboboxHighlightReason): void;
+    highlightIndex(index: number, reason: ComboboxHighlightReason): void;
+    setHighlight(item: ComboboxItemRef, reason: ComboboxHighlightReason): void;
+    clearHighlightState(): void;
+    private stepIndex;
+    /** Grid vertical move: keep the column index, jump to the adjacent row. */
+    private gridVertical;
+    /** Visible items grouped into rows by their nearest `[rdxAutocompleteRow]` ancestor (DOM order). */
+    private gridRows;
+    clearValue(): void;
+    /** The trigger element, used as a focus fallback when the input lives inside the popup. */
+    triggerElement: HTMLElement | null;
+    focusInput(): void;
+    restoreFocusAfterSelect(): void;
+    markAsTouched(): void;
+    private commitValue;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteRoot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteRoot, "[rdxAutocompleteRoot]", ["rdxAutocompleteRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "loopFocus": { "alias": "loopFocus"; "required": false; "isSignal": true; }; "autoHighlight": { "alias": "autoHighlight"; "required": false; "isSignal": true; }; "highlightItemOnHover": { "alias": "highlightItemOnHover"; "required": false; "isSignal": true; }; "keepHighlight": { "alias": "keepHighlight"; "required": false; "isSignal": true; }; "openOnInputClick": { "alias": "openOnInputClick"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "submitOnItemClick": { "alias": "submitOnItemClick"; "required": false; "isSignal": true; }; "grid": { "alias": "grid"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "limit": { "alias": "limit"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "virtualized": { "alias": "virtualized"; "required": false; "isSignal": true; }; "by": { "alias": "by"; "required": false; "isSignal": true; }; "itemToStringValue": { "alias": "itemToStringValue"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "open": "openChange"; "onValueChange": "onValueChange"; "onOpenChange": "onOpenChange"; "onItemHighlighted": "onItemHighlighted"; "onOpenChangeComplete": "onOpenChangeComplete"; }, never, never, true, [{ directive: typeof i1$1.RdxPopper; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * An accessible label for the autocomplete. Registers its id so the input (and trigger) reference it
+ * via `aria-labelledby`. Reuses the combobox label behavior.
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteLabel {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteLabel, "[rdxAutocompleteLabel]", ["rdxAutocompleteLabel"], {}, {}, never, never, true, [{ directive: typeof i1.RdxComboboxLabel; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Optional wrapper around the input and its adornments (icon, clear, trigger). Mirrors the input's
+ * state via `data-*` so the whole group can be styled together (focus ring, disabled, etc.).
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteInputGroup {
+    protected readonly root: RdxAutocompleteRoot;
+    protected readonly dataAttr: (value: boolean) => "" | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteInputGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteInputGroup, "[rdxAutocompleteInputGroup]", ["rdxAutocompleteInputGroup"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * The autocomplete text input. Holds DOM focus at all times; the highlighted option is referenced via
+ * `aria-activedescendant`. In `both` / `inline` modes it shows the active item's inline completion
+ * with the completed suffix selected. Integrates with Field for labeling and validation state.
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteInput {
+    protected readonly root: RdxAutocompleteRoot;
+    private readonly element;
+    private readonly fieldRootContext;
+    /** The input id; Field labels and descriptions reference it for accessible relationships. */
+    readonly id: _angular_core.InputSignal<string>;
+    /** Marks the input as invalid independently of any Field state. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly ariaAutocomplete: _angular_core.Signal<_radix_ng_primitives_autocomplete.AutocompleteMode>;
+    protected readonly invalidState: _angular_core.Signal<boolean>;
+    protected readonly disabledState: _angular_core.Signal<boolean>;
+    protected readonly requiredState: _angular_core.Signal<boolean>;
+    protected readonly filledState: _angular_core.Signal<boolean>;
+    protected readonly focusedState: _angular_core.Signal<boolean>;
+    protected readonly describedBy: _angular_core.Signal<string | undefined>;
+    constructor();
+    /** Whether an IME composition is in progress (CJK). While composing, don't filter or select. */
+    protected composing: boolean;
+    onInput(event: Event): void;
+    onCompositionEnd(event: CompositionEvent): void;
+    private commitInput;
+    onClick(): void;
+    onFocus(): void;
+    onBlur(): void;
+    onKeydown(event: KeyboardEvent): void;
+    protected readonly dataAttr: (value: boolean) => "" | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteInput, "input[rdxAutocompleteInput]", ["rdxAutocompleteInput"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperAnchor; inputs: {}; outputs: {}; }, { directive: typeof i2.RdxDismissableLayerBranch; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Renders the current input value as text. Useful for a read-only display of the committed value.
+ * Read `slotText()` in the template. Exposes `data-placeholder` while the value is empty.
+ *
+ * @example
+ * <span #value="rdxAutocompleteValue" rdxAutocompleteValue placeholder="Empty">{{ value.slotText() }}</span>
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteValue {
+    private readonly root;
+    /** Text shown when the value is empty. */
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly isEmpty: _angular_core.Signal<boolean>;
+    /** The current input value, or the `placeholder` when empty. */
+    readonly slotText: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteValue, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteValue, "[rdxAutocompleteValue]", ["rdxAutocompleteValue"], { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Toggles the autocomplete popup. Carries `tabindex="-1"` so it never steals focus from the input.
+ * Reuses the combobox trigger behavior.
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteTrigger {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteTrigger, "button[rdxAutocompleteTrigger]", ["rdxAutocompleteTrigger"], {}, {}, never, never, true, [{ directive: typeof i1.RdxComboboxTrigger; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Decorative icon inside the trigger. Hidden from assistive technology. Reuses the combobox icon.
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteIcon {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteIcon, "[rdxAutocompleteIcon]", ["rdxAutocompleteIcon"], {}, {}, never, never, true, [{ directive: typeof i1.RdxComboboxIcon; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Clears the input value. Hidden when there is nothing to clear.
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteClear {
+    protected readonly root: RdxAutocompleteRoot;
+    protected readonly isEmpty: _angular_core.Signal<boolean>;
+    onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteClear, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteClear, "button[rdxAutocompleteClear]", ["rdxAutocompleteClear"], {}, {}, never, never, true, [{ directive: typeof i2.RdxDismissableLayerBranch; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Structural directive that teleports the autocomplete popup into a container (default
+ * `document.body`) while the autocomplete is open, keeping it mounted until any CSS exit `@keyframes`
+ * finishes. Composes the structural {@link RdxComboboxPortal} (which reads the open state from the
+ * combobox root context provided by `RdxAutocompleteRoot`).
+ *
+ * Apply it with the `*` microsyntax on the positioner —
+ * `<div *rdxAutocompletePortal rdxAutocompletePositioner>` — or as an explicit
+ * `<ng-template rdxAutocompletePortal>`. For a custom container use the explicit form with `[container]`.
+ *
+ * @group Components
+ */
+declare class RdxAutocompletePortal {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompletePortal, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompletePortal, "ng-template[rdxAutocompletePortal]", ["rdxAutocompletePortal"], {}, {}, never, never, true, [{ directive: typeof i1.RdxComboboxPortal; inputs: { "container": "container"; }; outputs: {}; }]>;
+}
+/**
+ * Dev-mode guard: `rdxAutocompletePortal` is now structural, so the old `<div rdxAutocompletePortal>`
+ * markup would silently stop portaling — fail loudly instead.
+ *
+ * @group Components
+ */
+declare class RdxAutocompletePortalMisuseGuard {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompletePortalMisuseGuard, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompletePortalMisuseGuard, "[rdxAutocompletePortal]:not(ng-template)", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * An overlay rendered beneath the popup in `modal` mode. Exposes `data-open` / `data-closed` for
+ * animation. Reuses the combobox backdrop.
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteBackdrop {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteBackdrop, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteBackdrop, "[rdxAutocompleteBackdrop]", ["rdxAutocompleteBackdrop"], {}, {}, never, never, true, [{ directive: typeof i1.RdxComboboxBackdrop; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Positions the popup relative to the input anchor using the popper engine. Composes the popper
+ * content wrapper directly (the same building block the combobox positioner uses) and re-exposes its
+ * positioning inputs.
+ *
+ * @group Components
+ */
+declare class RdxAutocompletePositioner {
+    readonly side: _angular_core.InputSignal<"top" | "right" | "bottom" | "left">;
+    readonly sideOffset: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly align: _angular_core.InputSignal<"center" | "end" | "start">;
+    readonly alignOffset: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly arrowPadding: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly avoidCollisions: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly collisionBoundary: _angular_core.InputSignal<ElementRef<HTMLElement> | ElementRef<HTMLElement>[] | undefined>;
+    readonly collisionPadding: _angular_core.InputSignal<number | Partial<Record<"top" | "right" | "bottom" | "left", number>>>;
+    readonly sticky: _angular_core.InputSignal<"always" | "partial">;
+    readonly hideWhenDetached: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly updatePositionStrategy: _angular_core.InputSignal<"always" | "optimized">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompletePositioner, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompletePositioner, "[rdxAutocompletePositioner]", ["rdxAutocompletePositioner"], { "side": { "alias": "side"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionBoundary": { "alias": "collisionBoundary"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "updatePositionStrategy": { "alias": "updatePositionStrategy"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperContentWrapper; inputs: { "side": "side"; "sideOffset": "sideOffset"; "align": "align"; "alignOffset": "alignOffset"; "arrowPadding": "arrowPadding"; "avoidCollisions": "avoidCollisions"; "collisionBoundary": "collisionBoundary"; "collisionPadding": "collisionPadding"; "sticky": "sticky"; "hideWhenDetached": "hideWhenDetached"; "updatePositionStrategy": "updatePositionStrategy"; }; outputs: {}; }]>;
+}
+
+/**
+ * The popup surface. Composes the popper content (for `data-side` / `data-align`) and a dismissable
+ * layer for outside-dismiss. It does **not** trap focus — focus stays in the input throughout. When
+ * the input lives **inside** the popup (the "input in popup" / emoji-picker pattern), it moves focus
+ * to the input once the popup is positioned.
+ *
+ * @group Components
+ */
+declare class RdxAutocompletePopup {
+    protected readonly root: RdxAutocompleteRoot;
+    private readonly dismissableLayer;
+    private readonly popper;
+    private readonly element;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompletePopup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompletePopup, "[rdxAutocompletePopup]", ["rdxAutocompletePopup"], {}, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperContent; inputs: {}; outputs: {}; }, { directive: typeof i2.RdxDismissableLayer; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * An optional arrow that points from the popup to the anchor. Composes the popper arrow directly
+ * (the same building block the combobox arrow uses).
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteArrow {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteArrow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteArrow, "[rdxAutocompleteArrow]", ["rdxAutocompleteArrow"], {}, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperArrow; inputs: { "width": "width"; "height": "height"; }; outputs: {}; }]>;
+}
+
+/**
+ * The listbox (or grid) container for suggestions. Carries the id referenced by the input's
+ * `aria-controls`, and switches its role to `grid` when the root has `grid` enabled.
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteList {
+    protected readonly root: RdxAutocompleteRoot;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteList, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteList, "[rdxAutocompleteList]", ["rdxAutocompleteList"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * A row in a grid-layout autocomplete list. Groups the items in one row so the root can navigate by
+ * row (ArrowUp / ArrowDown) and within a row (ArrowLeft / ArrowRight). Only meaningful when the root
+ * has `grid` enabled; the root resolves an item's row from its nearest `[rdxAutocompleteRow]` ancestor.
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteRow {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteRow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteRow, "[rdxAutocompleteRow]", ["rdxAutocompleteRow"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * A selectable suggestion. Registers itself with the root for filtering and navigation. Highlight is
+ * virtual (`data-highlighted` + `aria-activedescendant` on the input) — items never take DOM focus.
+ * Selecting an item writes its text into the input. Unlike the combobox item, the `value` is optional;
+ * when omitted, selection falls back to the option's text content (autocomplete's value is the input string).
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteItem implements ComboboxItemRef {
+    private readonly rootContext;
+    readonly element: HTMLElement;
+    readonly id: string;
+    /** The option's value. When omitted, selecting the item writes its text content into the input. */
+    readonly value: _angular_core.InputSignal<AcceptableValue>;
+    /** Explicit text matched against the query and written to the input. Defaults to text content. */
+    readonly textValueInput: _angular_core.InputSignal<string>;
+    /** Whether the option is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The option's index in the list. Required in virtualized mode. */
+    readonly index: _angular_core.InputSignal<number | undefined>;
+    protected readonly virtualized: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly autoTextValue;
+    readonly textValue: _angular_core.Signal<string>;
+    protected readonly elementId: _angular_core.Signal<string>;
+    protected readonly ariaSetSize: _angular_core.Signal<number | undefined>;
+    protected readonly ariaPosInSet: _angular_core.Signal<number | undefined>;
+    readonly isVisible: _angular_core.Signal<boolean>;
+    readonly isSelected: _angular_core.Signal<boolean>;
+    readonly isHighlighted: _angular_core.Signal<boolean>;
+    private readonly group;
+    constructor();
+    onPointerDown(event: MouseEvent): void;
+    onPointerUp(): void;
+    onPointerMove(): void;
+    onPointerLeave(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteItem, "[rdxAutocompleteItem]", ["rdxAutocompleteItem"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "textValueInput": { "alias": "textValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "index": { "alias": "index"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Renders only when its item is selected (e.g. a checkmark). Reuses the combobox item indicator,
+ * which reads the item context provided by {@link RdxAutocompleteItem}.
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteItemIndicator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteItemIndicator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteItemIndicator, "[rdxAutocompleteItemIndicator]", ["rdxAutocompleteItemIndicator"], {}, {}, never, never, true, [{ directive: typeof i1.RdxComboboxItemIndicator; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Groups related options under a shared label. Hides itself when all of its items are filtered out.
+ * Reuses the combobox group (and exposes the combobox group context for the label + items).
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteGroup {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteGroup, "[rdxAutocompleteGroup]", ["rdxAutocompleteGroup"], {}, {}, never, never, true, [{ directive: typeof i1.RdxComboboxGroup; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Accessible label for a {@link RdxAutocompleteGroup}. Wires itself up via `aria-labelledby`. Reuses
+ * the combobox group label.
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteGroupLabel {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteGroupLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteGroupLabel, "[rdxAutocompleteGroupLabel]", ["rdxAutocompleteGroupLabel"], {}, {}, never, never, true, [{ directive: typeof i1.RdxComboboxGroupLabel; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Shown only when no items match the current query. Reuses the combobox empty part.
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteEmpty {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteEmpty, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteEmpty, "[rdxAutocompleteEmpty]", ["rdxAutocompleteEmpty"], {}, {}, never, never, true, [{ directive: typeof i1.RdxComboboxEmpty; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * A polite live region for async status (loading, result counts) announced without moving focus.
+ * Reuses the combobox status region.
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteStatus {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteStatus, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteStatus, "[rdxAutocompleteStatus]", ["rdxAutocompleteStatus"], {}, {}, never, never, true, [{ directive: typeof i1.RdxComboboxStatus; inputs: {}; outputs: {}; }]>;
+}
+
+declare const _importsAutocomplete: (typeof RdxAutocompleteAnchor)[];
+declare class RdxAutocompleteModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxAutocompleteModule, never, [typeof RdxAutocompleteRoot, typeof RdxAutocompleteAnchor, typeof RdxAutocompleteLabel, typeof RdxAutocompleteInputGroup, typeof RdxAutocompleteInput, typeof RdxAutocompleteValue, typeof RdxAutocompleteTrigger, typeof RdxAutocompleteIcon, typeof RdxAutocompleteClear, typeof RdxAutocompletePortal, typeof RdxAutocompletePortalMisuseGuard, typeof RdxAutocompleteBackdrop, typeof RdxAutocompletePositioner, typeof RdxAutocompletePopup, typeof RdxAutocompleteArrow, typeof RdxAutocompleteList, typeof RdxAutocompleteRow, typeof RdxAutocompleteItem, typeof RdxAutocompleteItemIndicator, typeof RdxAutocompleteGroup, typeof RdxAutocompleteGroupLabel, typeof RdxAutocompleteEmpty, typeof RdxAutocompleteStatus], [typeof RdxAutocompleteRoot, typeof RdxAutocompleteAnchor, typeof RdxAutocompleteLabel, typeof RdxAutocompleteInputGroup, typeof RdxAutocompleteInput, typeof RdxAutocompleteValue, typeof RdxAutocompleteTrigger, typeof RdxAutocompleteIcon, typeof RdxAutocompleteClear, typeof RdxAutocompletePortal, typeof RdxAutocompletePortalMisuseGuard, typeof RdxAutocompleteBackdrop, typeof RdxAutocompletePositioner, typeof RdxAutocompletePopup, typeof RdxAutocompleteArrow, typeof RdxAutocompleteList, typeof RdxAutocompleteRow, typeof RdxAutocompleteItem, typeof RdxAutocompleteItemIndicator, typeof RdxAutocompleteGroup, typeof RdxAutocompleteGroupLabel, typeof RdxAutocompleteEmpty, typeof RdxAutocompleteStatus]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxAutocompleteModule>;
+}
+
+export { RdxAutocompleteAnchor, RdxAutocompleteArrow, RdxAutocompleteBackdrop, RdxAutocompleteClear, RdxAutocompleteEmpty, RdxAutocompleteGroup, RdxAutocompleteGroupLabel, RdxAutocompleteIcon, RdxAutocompleteInput, RdxAutocompleteInputGroup, RdxAutocompleteItem, RdxAutocompleteItemIndicator, RdxAutocompleteLabel, RdxAutocompleteList, RdxAutocompleteModule, RdxAutocompletePopup, RdxAutocompletePortal, RdxAutocompletePortalMisuseGuard, RdxAutocompletePositioner, RdxAutocompleteRoot, RdxAutocompleteRow, RdxAutocompleteStatus, RdxAutocompleteTrigger, RdxAutocompleteValue, _importsAutocomplete };
+export type { AutocompleteChangeReason, AutocompleteFilter, AutocompleteMode, AutocompleteValueChangeDetails };