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

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

@@ -0,0 +1,661 @@
+import * as _angular_core from '@angular/core';
+import * as _radix_ng_primitives_combobox from '@radix-ng/primitives/combobox';
+import { RdxComboboxOpenChange, ComboboxItemHighlightedDetails, ComboboxInputLayout, ComboboxItemRef, RdxComboboxOpenChangeReason, 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, RdxFloatingRootContext, Direction, BooleanInput, ItemValueComparator } from '@radix-ng/primitives/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i1 from '@radix-ng/primitives/popper';
+import { RdxPopperContentWrapper } 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';
+import * as _radix_ng_primitives_types_radix_ng_primitives_core from '@radix-ng/primitives/types/radix-ng-primitives-core';
+
+/**
+ * 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 _radix_ng_primitives_combobox.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, matching Base UI's signature: the item's raw value (the object for object
+ * items), the query, and an `itemToString` resolver. Value-first lets one filter match strings and
+ * objects alike (fuzzy / multi-key). The same shape as the shared combobox engine's `ComboboxFilter`.
+ */
+type AutocompleteFilter = (itemValue: AcceptableValue, query: string, itemToString?: (itemValue: AcceptableValue) => string) => 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. A thin configuration over
+ * the shared combobox engine (ADR 0014) with `selectionMode: 'none'`, so its value **is** the input
+ * string: typing, selecting an item, or clearing all change a single string value. Implements
+ * `ControlValueAccessor` (the form value is the input string).
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteRoot implements ControlValueAccessor {
+    private readonly injector;
+    /** Per-popup floating root context (ADR 0015) — `open` / `triggers` / reference for the dismissal engine. */
+    readonly floatingContext: RdxFloatingRootContext;
+    /** 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 dirInput: _angular_core.InputSignal<Direction | undefined>;
+    readonly dir: _angular_core.Signal<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. */
+    readonly highlightItemOnHover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether a pointer-driven highlight is kept when the cursor leaves the list. */
+    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` → locale-aware contains; a function → custom `(value, query, itemToString)`; `null` →
+     * built-in filtering disabled.
+     */
+    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 for {@link virtualized} mode. */
+    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 (a comparator function or an object key). Base UI prop name. */
+    readonly isItemEqualToValue: _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<RdxComboboxOpenChange>;
+    /** 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>;
+    /** 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 preventUnmountOnClose;
+    readonly present: _angular_core.Signal<boolean>;
+    /** Whether built-in filtering applies in the current mode (`list` / `both`). */
+    private readonly filteringMode;
+    /** Whether inline completion applies in the current mode (`both` / `inline`). */
+    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; 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>;
+    /** The shared engine: item registry, filtering, highlight navigation (grid), inline, transition. */
+    private readonly engine;
+    /** What the input element displays: the inline preview if any, else the committed value. */
+    readonly displayValue: _angular_core.Signal<string>;
+    get listId(): string;
+    get labelId(): _angular_core.Signal<string | undefined>;
+    get inputElement(): _angular_core.Signal<HTMLInputElement | null>;
+    setInputElement(el: HTMLInputElement | null): void;
+    setInputLayout(layout: ComboboxInputLayout): void;
+    setPopupMounted(value: boolean): void;
+    get inputLayout(): _angular_core.Signal<ComboboxInputLayout>;
+    get openedByTouch(): _angular_core.Signal<boolean>;
+    get popupMounted(): _angular_core.Signal<boolean>;
+    get highlight(): _radix_ng_primitives_core.ListHighlight<ComboboxItemRef>;
+    get highlightedItem(): _angular_core.Signal<ComboboxItemRef | null>;
+    get highlightedIndex(): _angular_core.Signal<number>;
+    get activeId(): _angular_core.Signal<string | undefined>;
+    get filteredItems(): _angular_core.Signal<readonly AcceptableValue[]>;
+    get visibleCount(): _angular_core.Signal<number>;
+    get inlinePreview(): _angular_core.Signal<string | null>;
+    get transitionStatus(): _angular_core.Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
+    get registerTransitionElement(): (element: HTMLElement) => () => void;
+    get triggerElement(): HTMLElement | null;
+    private onChange?;
+    private onTouched?;
+    constructor();
+    setSuppressInline(value: boolean): void;
+    /** Opens the popup for browsing (resets the query to "pristine" and selects the input text). */
+    openForBrowse(reason?: RdxComboboxOpenChangeReason, event?: Event): void;
+    /** Opens the popup and highlights the given edge once the list mounts. */
+    openAndHighlight(edge: 'first' | 'last', reason?: RdxComboboxOpenChangeReason, event?: Event): void;
+    /** Whether the item's value/label matches the current input value (combobox context contract). */
+    isSelectedValue(value: AcceptableValue): boolean;
+    setOpen(open: boolean, reason?: RdxComboboxOpenChangeReason, event?: Event): boolean;
+    closePopup(revert?: boolean, reason?: RdxComboboxOpenChangeReason, event?: Event): void;
+    /** Updates the input text from user typing (marks it a fresh query, emits change). */
+    setQuery(value: string): void;
+    labelFor(value: AcceptableValue): string;
+    itemId(index: number): string;
+    isVisible(item: ComboboxItemRef): boolean;
+    registerItem(item: ComboboxItemRef): void;
+    unregisterItem(item: ComboboxItemRef): void;
+    handleSelect(item: ComboboxItemRef, event?: Event): void;
+    /** Selects the filtered item at `index` (virtualized mode). */
+    selectIndex(index: number, event?: Event): void;
+    /** Commits a selection: the input value becomes the item's label, the popup closes. */
+    private commitSelection;
+    private maybeSubmit;
+    selectHighlighted(event?: Event): void;
+    navigateByKeyboard(direction: 1 | -1, event?: Event): void;
+    moveDown(): void;
+    moveUp(): void;
+    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;
+    isKeyboardActive(): boolean;
+    setKeyboardActive(value: boolean): void;
+    clearValue(): void;
+    focusInput(): void;
+    markAsTouched(): void;
+    private commitValue;
+    private createOpenChangeEvent;
+    private resolveOpenChangeTrigger;
+    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; }; "dirInput": { "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; }; "isItemEqualToValue": { "alias": "isItemEqualToValue"; "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.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 _radix_ng_primitives_combobox.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(event: MouseEvent): 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.RdxPopperAnchor; inputs: {}; outputs: {}; }, { directive: typeof i2.RdxFloatingInsideElement; 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. Reuses the combobox trigger: a `tabindex="-1"` toggle when the input
+ * sits outside the popup, or the focusable `role="combobox"` control when the input is inside it.
+ *
+ * @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 _radix_ng_primitives_combobox.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 _radix_ng_primitives_combobox.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>;
+    /** Disabled when the control is disabled or read-only (clearing is a mutation). */
+    protected readonly isDisabled: _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.RdxFloatingInsideElement; 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 _radix_ng_primitives_combobox.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 _radix_ng_primitives_combobox.RdxComboboxBackdrop; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Positions the autocomplete popup relative to the input anchor using the popper engine.
+ *
+ * A "thin" positioner (ADR 0012): it inherits the full popper positioning surface — the inputs
+ * (`side`, `sideOffset`, `align`, …), the `placed` output, and the host bindings — from
+ * {@link RdxPopperContentWrapper}, and only declares autocomplete's Base UI-aligned defaults through
+ * the config provider (the same building block the combobox positioner uses).
+ *
+ * @group Components
+ */
+declare class RdxAutocompletePositioner extends RdxPopperContentWrapper {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompletePositioner, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompletePositioner, "[rdxAutocompletePositioner]", ["rdxAutocompletePositioner"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * 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 floatingContext;
+    private readonly registration;
+    private readonly popper;
+    private readonly element;
+    constructor();
+    /**
+     * Base UI focus handoff: if focus lands on the popup or the list (the `tabindex="-1"` programmatic
+     * focus targets), hand it back to the input so arrow-key navigation (`aria-activedescendant`) keeps
+     * working. Skipped for a touch interaction, where focus is parked on the popup to keep the Android
+     * virtual keyboard closed.
+     */
+    onFocusIn(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompletePopup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompletePopup, "[rdxAutocompletePopup]", ["rdxAutocompletePopup"], {}, {}, never, never, true, [{ directive: typeof i1.RdxPopperContent; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_core.RdxFloatingNodeRegistration; 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.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;
+    onKeydown(event: KeyboardEvent): void;
+    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 visual separator between groups of suggestions (`role="separator"`). Reuses the combobox separator.
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteSeparator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteSeparator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteSeparator, "[rdxAutocompleteSeparator]", ["rdxAutocompleteSeparator"], {}, {}, never, never, true, [{ directive: typeof _radix_ng_primitives_combobox.RdxComboboxSeparator; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * 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 explicit `[value]`, or `undefined` when omitted. Read the resolved {@link value} instead —
+     * it falls back to the text content only when no value was bound (so explicit falsy values like
+     * `0` / `''` / `null` are preserved for the filter and selection).
+     */
+    readonly valueInput: _angular_core.InputSignal<AcceptableValue | undefined>;
+    /** 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>;
+    /**
+     * The option's effective value: the explicit `[value]` if bound (preserving `0` / `''` / `null`),
+     * otherwise the text content (autocomplete's value is the input string). Only an absent input —
+     * `undefined` — falls back, so a custom filter still sees the real `itemValue` for falsy values.
+     */
+    readonly value: _angular_core.Signal<AcceptableValue>;
+    protected readonly elementId: _angular_core.Signal<string>;
+    protected readonly ariaSetSize: _angular_core.Signal<number | undefined>;
+    protected readonly ariaPosInSet: _angular_core.Signal<number | undefined>;
+    /** The nearest enclosing grid row, if any (drives the `gridcell` role). */
+    private readonly row;
+    /** `gridcell` only when actually inside a `RdxAutocompleteRow` of a grid list; otherwise `option`. */
+    protected readonly role: _angular_core.Signal<"gridcell" | "option">;
+    readonly isVisible: _angular_core.Signal<boolean>;
+    readonly isSelected: _angular_core.Signal<boolean>;
+    readonly isHighlighted: _angular_core.Signal<boolean>;
+    private readonly group;
+    constructor();
+    private pointerDownStarted;
+    onPointerDown(event: MouseEvent): void;
+    onMouseDown(event: MouseEvent): void;
+    onMouseUp(event: MouseEvent): void;
+    onClick(): void;
+    private commitSelection;
+    onPointerMove(): void;
+    onPointerLeave(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteItem, "[rdxAutocompleteItem]", ["rdxAutocompleteItem"], { "valueInput": { "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 _radix_ng_primitives_combobox.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 _radix_ng_primitives_combobox.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 _radix_ng_primitives_combobox.RdxComboboxGroupLabel; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * A polite, atomic live region announcing the "no results" message. Like the combobox empty part, the
+ * element stays mounted and visible at all times (never hidden/unmounted) so the transition to empty is
+ * announced; only its projected content is rendered conditionally.
+ *
+ * @group Components
+ */
+declare class RdxAutocompleteEmpty {
+    protected readonly rootContext: {
+        listId: string;
+        labelId: _angular_core.Signal<string | undefined>;
+        setLabelId: (id: string | undefined) => void;
+        dir: _angular_core.Signal<_radix_ng_primitives_types_radix_ng_primitives_core.Direction>;
+        value: _angular_core.ModelSignal<_radix_ng_primitives_combobox.ComboboxValue>;
+        inputValue: _angular_core.ModelSignal<string>;
+        open: _angular_core.ModelSignal<boolean>;
+        present: _angular_core.Signal<boolean>;
+        multiple: _angular_core.Signal<boolean>;
+        selectionMode: _angular_core.Signal<"none" | "single" | "multiple">;
+        disabledState: _angular_core.Signal<boolean>;
+        readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        requiredState: _angular_core.Signal<boolean>;
+        openOnInputClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        modal: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        virtualized: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        grid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        filteredItems: _angular_core.Signal<readonly _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue[]>;
+        highlightedItem: _angular_core.Signal<_radix_ng_primitives_combobox.ComboboxItemRef | null>;
+        highlightedIndex: _angular_core.Signal<number>;
+        activeId: _angular_core.Signal<string | undefined>;
+        itemId: (index: number) => string;
+        isKeyboardActive: () => boolean;
+        setKeyboardActive: (value: boolean) => void;
+        transitionStatus: _angular_core.Signal<_radix_ng_primitives_types_radix_ng_primitives_core.RdxTransitionStatus>;
+        registerTransitionElement: (element: HTMLElement) => () => void;
+        visibleCount: _angular_core.Signal<number>;
+        isVisible: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => boolean;
+        isSelected: (value: _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue) => boolean;
+        registerItem: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
+        unregisterItem: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
+        highlight: _radix_ng_primitives_types_radix_ng_primitives_core.ListHighlight<_radix_ng_primitives_combobox.ComboboxItemRef>;
+        highlightNext: () => void;
+        highlightPrevious: () => void;
+        highlightNextColumn: () => void;
+        highlightPreviousColumn: () => void;
+        highlightFirst: () => void;
+        highlightLast: () => void;
+        highlightIndex: (index: number, reason: _radix_ng_primitives_combobox.ComboboxHighlightReason) => void;
+        setHighlight: (item: _radix_ng_primitives_combobox.ComboboxItemRef, reason: _radix_ng_primitives_combobox.ComboboxHighlightReason) => void;
+        clearHighlight: () => void;
+        highlightItemOnHover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        keepHighlight: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        inputElement: _angular_core.Signal<HTMLInputElement | null>;
+        setInputElement: (el: HTMLInputElement | null) => void;
+        inputLayout: _angular_core.Signal<_radix_ng_primitives_combobox.ComboboxInputLayout>;
+        setInputLayout: (layout: _radix_ng_primitives_combobox.ComboboxInputLayout) => void;
+        openedByTouch: _angular_core.Signal<boolean>;
+        setOpenedByTouch: (value: boolean) => void;
+        popupMounted: _angular_core.Signal<boolean>;
+        setPopupMounted: (value: boolean) => void;
+        registerTrigger: (el: HTMLElement | null) => void;
+        focusInput: () => void;
+        openPopup: (reason?: _radix_ng_primitives_combobox.RdxComboboxOpenChangeReason, event?: Event) => boolean;
+        openForBrowse: (reason?: _radix_ng_primitives_combobox.RdxComboboxOpenChangeReason, event?: Event) => void;
+        closePopup: (revert?: boolean, reason?: _radix_ng_primitives_combobox.RdxComboboxOpenChangeReason, event?: Event) => void;
+        setInputValue: (value: string) => void;
+        openAndHighlight: (edge: "first" | "last", reason?: _radix_ng_primitives_combobox.RdxComboboxOpenChangeReason, event?: Event) => void;
+        navigateByKeyboard: (direction: 1 | -1, event?: Event) => void;
+        select: (item: _radix_ng_primitives_combobox.ComboboxItemRef, event?: Event) => void;
+        selectIndex: (index: number, event?: Event) => void;
+        selectHighlighted: (event?: Event) => void;
+        clearSelection: () => void;
+        removeValue: (value: _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue) => void;
+        removeLastValue: () => void;
+        registerChipsNav: (fn: (() => boolean) | null) => void;
+        focusLastChip: () => boolean;
+        labelFor: (value: _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue) => string;
+        markAsTouched: () => void;
+    };
+    /** Whether no items match the current query (drives projection of the message). */
+    protected readonly isEmpty: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAutocompleteEmpty, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RdxAutocompleteEmpty, "[rdxAutocompleteEmpty]", ["rdxAutocompleteEmpty"], {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * 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 _radix_ng_primitives_combobox.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 RdxAutocompleteSeparator, 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 RdxAutocompleteSeparator, 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, RdxAutocompleteSeparator, RdxAutocompleteStatus, RdxAutocompleteTrigger, RdxAutocompleteValue, _importsAutocomplete };
+export type { AutocompleteChangeReason, AutocompleteFilter, AutocompleteMode, AutocompleteValueChangeDetails };