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

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

@@ -1,14 +1,15 @@
 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';
+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, Direction, BooleanInput, ItemValueComparator } from '@radix-ng/primitives/core';
+import { AcceptableValue, RdxFloatingRootContext, Direction, BooleanInput, ItemValueComparator } from '@radix-ng/primitives/core';
 import { ControlValueAccessor } from '@angular/forms';
-import * as i1$1 from '@radix-ng/primitives/popper';
+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
@@ -19,7 +20,7 @@ import * as i2 from '@radix-ng/primitives/dismissable-layer';
  */
 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: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteAnchor, "[rdxAutocompleteAnchor]", ["rdxAutocompleteAnchor"], {}, {}, never, never, true, [{ directive: typeof _radix_ng_primitives_combobox.RdxComboboxAnchor; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -31,10 +32,11 @@ declare class RdxAutocompleteAnchor {
  */
 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.
+ * 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 = (itemText: string, query: string, itemValue: AcceptableValue) => boolean;
+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. */
@@ -46,16 +48,17 @@ interface AutocompleteValueChangeDetails {
 }
 
 /**
- * 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
+ * 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. */
@@ -67,7 +70,8 @@ declare class RdxAutocompleteRoot implements ControlValueAccessor {
     /** Filtering / inline-completion behavior. See {@link AutocompleteMode}. */
     readonly mode: _angular_core.InputSignal<AutocompleteMode>;
     /** Text direction. */
-    readonly dir: _angular_core.InputSignal<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. */
@@ -85,17 +89,9 @@ declare class RdxAutocompleteRoot implements ControlValueAccessor {
     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.
-     */
+    /** 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. `false` (default)
-     * clears the highlight on pointer-leave; `true` retains the last hovered item highlighted. Keyboard
-     * navigation and auto-highlight are unaffected.
-     */
+    /** 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>;
@@ -107,134 +103,100 @@ declare class RdxAutocompleteRoot implements ControlValueAccessor {
     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).
+     * `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, used as the source of truth for filtering and navigation in
-     * {@link virtualized} mode (where only a window of `RdxAutocompleteItem` is mounted).
-     */
+    /** 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 (function or object key). */
-    readonly by: _angular_core.InputSignal<ItemValueComparator<AcceptableValue> | undefined>;
+    /** 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<boolean>;
+    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>;
-    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 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. */
+    /** 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 so the user can
-     * browse; it flips `true` on the first keystroke.
+     * `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>;
-    /** Transient inline-completion preview (the active item's label), or `null`. */
-    readonly inlinePreview: _angular_core.WritableSignal<string | null>;
+    /** 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>;
-    /** 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;
+    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();
-    private recomputeInlinePreview;
     setSuppressInline(value: boolean): void;
     /** Opens the popup for browsing (resets the query to "pristine" and selects the input text). */
-    openForBrowse(): void;
+    openForBrowse(reason?: RdxComboboxOpenChangeReason, event?: Event): 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;
+    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;
-    registerItem(item: ComboboxItemRef): void;
-    unregisterItem(item: ComboboxItemRef): void;
-    setOpen(open: boolean): void;
-    closePopup(revert?: boolean): void;
+    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;
-    /** 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;
+    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): void;
+    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(): void;
+    selectHighlighted(event?: Event): void;
+    navigateByKeyboard(direction: 1 | -1, event?: Event): 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;
@@ -242,24 +204,20 @@ declare class RdxAutocompleteRoot implements ControlValueAccessor {
     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;
+    isKeyboardActive(): boolean;
+    setKeyboardActive(value: boolean): void;
     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;
+    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; }; "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: {}; }]>;
+    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: {}; }]>;
 }
 
 /**
@@ -270,7 +228,7 @@ declare class RdxAutocompleteRoot implements ControlValueAccessor {
  */
 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: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteLabel, "[rdxAutocompleteLabel]", ["rdxAutocompleteLabel"], {}, {}, never, never, true, [{ directive: typeof _radix_ng_primitives_combobox.RdxComboboxLabel; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -314,13 +272,13 @@ declare class RdxAutocompleteInput {
     onInput(event: Event): void;
     onCompositionEnd(event: CompositionEvent): void;
     private commitInput;
-    onClick(): void;
+    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$1.RdxPopperAnchor; inputs: {}; outputs: {}; }, { directive: typeof i2.RdxDismissableLayerBranch; inputs: {}; outputs: {}; }]>;
+    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: {}; }]>;
 }
 
 /**
@@ -344,14 +302,14 @@ declare class RdxAutocompleteValue {
 }
 
 /**
- * Toggles the autocomplete popup. Carries `tabindex="-1"` so it never steals focus from the input.
- * Reuses the combobox trigger behavior.
+ * 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 i1.RdxComboboxTrigger; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteTrigger, "button[rdxAutocompleteTrigger]", ["rdxAutocompleteTrigger"], {}, {}, never, never, true, [{ directive: typeof _radix_ng_primitives_combobox.RdxComboboxTrigger; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -361,7 +319,7 @@ declare class RdxAutocompleteTrigger {
  */
 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: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteIcon, "[rdxAutocompleteIcon]", ["rdxAutocompleteIcon"], {}, {}, never, never, true, [{ directive: typeof _radix_ng_primitives_combobox.RdxComboboxIcon; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -372,9 +330,11 @@ declare class RdxAutocompleteIcon {
 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.RdxDismissableLayerBranch; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteClear, "button[rdxAutocompleteClear]", ["rdxAutocompleteClear"], {}, {}, never, never, true, [{ directive: typeof i2.RdxFloatingInsideElement; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -391,7 +351,7 @@ declare class RdxAutocompleteClear {
  */
 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: {}; }]>;
+    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>`
@@ -413,30 +373,23 @@ declare class RdxAutocompletePortalMisuseGuard {
  */
 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: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteBackdrop, "[rdxAutocompleteBackdrop]", ["rdxAutocompleteBackdrop"], {}, {}, never, never, true, [{ directive: typeof _radix_ng_primitives_combobox.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.
+ * 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 {
-    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">;
+declare class RdxAutocompletePositioner extends RdxPopperContentWrapper {
+    constructor();
     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: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompletePositioner, "[rdxAutocompletePositioner]", ["rdxAutocompletePositioner"], {}, {}, never, never, true, never>;
 }
 
 /**
@@ -449,12 +402,20 @@ declare class RdxAutocompletePositioner {
  */
 declare class RdxAutocompletePopup {
     protected readonly root: RdxAutocompleteRoot;
-    private readonly dismissableLayer;
+    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$1.RdxPopperContent; inputs: {}; outputs: {}; }, { directive: typeof i2.RdxDismissableLayer; inputs: {}; outputs: {}; }]>;
+    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: {}; }]>;
 }
 
 /**
@@ -465,7 +426,7 @@ declare class RdxAutocompletePopup {
  */
 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: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteArrow, "[rdxAutocompleteArrow]", ["rdxAutocompleteArrow"], {}, {}, never, never, true, [{ directive: typeof i1.RdxPopperArrow; inputs: { "width": "width"; "height": "height"; }; outputs: {}; }]>;
 }
 
 /**
@@ -476,6 +437,7 @@ declare class RdxAutocompleteArrow {
  */
 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>;
 }
@@ -492,6 +454,16 @@ declare class RdxAutocompleteRow {
     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.
@@ -504,8 +476,12 @@ 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>;
+    /**
+     * 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. */
@@ -515,20 +491,34 @@ declare class RdxAutocompleteItem implements ComboboxItemRef {
     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;
-    onPointerUp(): 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"], { "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>;
+    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>;
 }
 
 /**
@@ -539,7 +529,7 @@ declare class RdxAutocompleteItem implements ComboboxItemRef {
  */
 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: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteItemIndicator, "[rdxAutocompleteItemIndicator]", ["rdxAutocompleteItemIndicator"], {}, {}, never, never, true, [{ directive: typeof _radix_ng_primitives_combobox.RdxComboboxItemIndicator; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -550,7 +540,7 @@ declare class RdxAutocompleteItemIndicator {
  */
 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: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteGroup, "[rdxAutocompleteGroup]", ["rdxAutocompleteGroup"], {}, {}, never, never, true, [{ directive: typeof _radix_ng_primitives_combobox.RdxComboboxGroup; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -561,17 +551,92 @@ declare class RdxAutocompleteGroup {
  */
 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: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteGroupLabel, "[rdxAutocompleteGroupLabel]", ["rdxAutocompleteGroupLabel"], {}, {}, never, never, true, [{ directive: typeof _radix_ng_primitives_combobox.RdxComboboxGroupLabel; inputs: {}; outputs: {}; }]>;
 }
 
 /**
- * Shown only when no items match the current query. Reuses the combobox empty part.
+ * 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 ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAutocompleteEmpty, "[rdxAutocompleteEmpty]", ["rdxAutocompleteEmpty"], {}, {}, never, never, true, [{ directive: typeof i1.RdxComboboxEmpty; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RdxAutocompleteEmpty, "[rdxAutocompleteEmpty]", ["rdxAutocompleteEmpty"], {}, {}, never, ["*"], true, never>;
 }
 
 /**
@@ -582,15 +647,15 @@ declare class RdxAutocompleteEmpty {
  */
 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: {}; }]>;
+    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 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 ɵ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, RdxAutocompleteStatus, RdxAutocompleteTrigger, RdxAutocompleteValue, _importsAutocomplete };
+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 };