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

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

@@ -1,14 +1,15 @@
 import * as _angular_core from '@angular/core';
-import { Signal, ElementRef } from '@angular/core';
+import { Signal, Injector } from '@angular/core';
 import * as i1 from '@radix-ng/primitives/popper';
+import { RdxPopperContentWrapper } from '@radix-ng/primitives/popper';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { AcceptableValue, Direction, ItemValueComparator, BooleanInput } from '@radix-ng/primitives/core';
+import { AcceptableValue, RdxFloatingRootContext, Direction, BooleanInput, ItemValueComparator, RdxCancelableChangeEventDetails } from '@radix-ng/primitives/core';
 import { ControlValueAccessor } from '@angular/forms';
 import * as _radix_ng_primitives_combobox from '@radix-ng/primitives/combobox';
 import * as i1$1 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';
 import * as i1$2 from '@radix-ng/primitives/portal';
-import * as i1$3 from '@radix-ng/primitives/presence';
+import { RdxPortalContainer } from '@radix-ng/primitives/portal';
 
 /**
  * Optional positioning anchor for the popup. Put it on the element the popup should align to — for
@@ -24,12 +25,10 @@ declare class RdxComboboxAnchor {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxAnchor, "[rdxComboboxAnchor]", ["rdxComboboxAnchor"], {}, {}, never, never, true, [{ directive: typeof i1.RdxPopperAnchor; inputs: {}; outputs: {}; }]>;
 }
 
-/** The value a combobox can hold: a single value, an array (multiple mode), or nothing. */
-type ComboboxValue = AcceptableValue | AcceptableValue[];
 /**
- * A combobox item, registered with the root so it participates in filtering, navigation, and
- * selection. Implemented by `RdxComboboxItem`; the root only depends on this structural shape to
- * avoid a circular import.
+ * A combobox item, registered with the engine so it participates in filtering, navigation, and
+ * selection. Implemented by `RdxComboboxItem` (and `RdxAutocompleteItem`); the engine depends only on
+ * this structural shape to avoid a circular import.
  */
 interface ComboboxItemRef {
     /** The option's element id, exposed via `aria-activedescendant` when highlighted. */
@@ -43,49 +42,189 @@ interface ComboboxItemRef {
     /** Whether the option is disabled. */
     readonly disabled: Signal<boolean>;
 }
-/** A custom filter predicate: `(itemText, query) => matches`. */
-type ComboboxFilter = (itemText: string, query: string) => boolean;
+/**
+ * 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 that converts a value to its display/match text.
+ * Value-first lets one filter match strings and objects alike (fuzzy / multi-key); the resolver gives
+ * the text when needed. The shared engine contract; autocomplete's filter is the same shape.
+ */
+type ComboboxFilter = (itemValue: AcceptableValue, query: string, itemToString?: (itemValue: AcceptableValue) => string) => boolean;
 /** Why the highlight moved: keyboard navigation, pointer hover, or a programmatic change. */
 type ComboboxHighlightReason = 'keyboard' | 'pointer' | 'none';
-/** Payload of {@link RdxComboboxRoot.onItemHighlighted}. */
+/**
+ * Where the text input sits relative to the popup (Base UI's `inputInsidePopup`). `unknown` until an
+ * input mounts — so a Trigger whose input lives in a not-yet-opened popup is still `Tab`-reachable.
+ */
+type ComboboxInputLayout = 'unknown' | 'inside' | 'outside';
+/** Payload of the highlight-changed emit. */
 interface ComboboxItemHighlightedDetails {
     /** The highlighted item's value, or `null` when the highlight is cleared. */
     value: AcceptableValue | null;
     /**
      * The highlighted item's index in the visible/filtered list (`-1` when cleared). In virtualized
-     * mode this is the index into {@link RdxComboboxRoot.filteredItems} — pass it to the virtualizer's
-     * `scrollToIndex` so the item mounts before it needs DOM focus.
+     * mode this is the index into {@link ComboboxEngine.filteredItems}.
      */
     index: number;
     /** What caused the highlight to move. */
     reason: ComboboxHighlightReason;
 }
+/** The reactive inputs and callbacks a root hands the engine. */
+interface ComboboxEngineConfig {
+    /** Injection context for the engine's effects/hooks. */
+    injector: Injector;
+    /** Prefix for the generated list id (e.g. `'rdx-combobox-list-'`). */
+    listIdPrefix: string;
+    /** CSS selector of the popup, used to decide focus restoration after a selection. */
+    popupSelector: string;
+    /** Whether the popup is open (the root owns the model; the engine only reads it). */
+    open: Signal<boolean>;
+    /** The active query string (the root derives it from its own typed/value semantics). */
+    query: Signal<string>;
+    /** Whether built-in filtering applies (always `true` for combobox; mode-gated for autocomplete). */
+    filteringEnabled: Signal<boolean>;
+    /** Whether keyboard navigation wraps at the list boundaries. */
+    loopFocus: Signal<boolean>;
+    /** Resolved auto-highlight mode. */
+    autoHighlightMode: Signal<'off' | 'input-change' | 'always'>;
+    /** Whether the list is externally virtualized (navigation runs over {@link items} by index). */
+    virtualized: Signal<boolean>;
+    /** Full set of item values for virtualized mode; `undefined` for DOM-driven lists. */
+    items: Signal<readonly AcceptableValue[] | undefined>;
+    /** Filter: `undefined` → default contains; a function → custom; `null` → built-in filtering off. */
+    filter: Signal<ComboboxFilter | null | undefined>;
+    /** Maximum number of matching items to show (`-1` = no limit). */
+    limit: Signal<number>;
+    /** Whether the list is a 2D grid (row/column arrow navigation). Defaults off for plain lists. */
+    grid: Signal<boolean>;
+    /** Resolves an item element to its enclosing row element (e.g. the nearest `[rdxComboboxRow]`). */
+    rowOf: (element: HTMLElement) => Element | null;
+    /**
+     * Whether inline completion is active (autocomplete `both` / `inline` modes). When on, the engine
+     * maintains an {@link ComboboxEngine.inlinePreview} that mirrors the highlighted item's label into
+     * the input. Always `false` for combobox (it never inline-completes).
+     */
+    inlineMode: Signal<boolean>;
+    /**
+     * Resolves a raw item value to its display/match text — the `itemToString` Base UI passes to the
+     * filter. DOM-aware (finds a mounted item by value and returns its text) so it works for both
+     * DOM-driven and virtualized lists.
+     */
+    itemToString: (value: AcceptableValue) => string;
+    /** Emits when the highlight moves (the root wires this to its `onItemHighlighted` output). */
+    onItemHighlighted: (details: ComboboxItemHighlightedDetails) => void;
+    /** Emits when open changes (skips the initial run); the root wires its `onOpenChange` output. */
+    onOpenChange: (open: boolean) => void;
+    /** Called after the open/close transition (including any exit animation) finishes. */
+    onOpenChangeComplete: (open: boolean) => void;
+}
+/**
+ * The shared Combobox engine (ADR 0014): item registry, filtering, highlight-model navigation,
+ * open/close transition, and the reactive effects that tie them together — everything Combobox and
+ * Autocomplete have in common. Value/selection semantics, open orchestration, and forms integration
+ * stay in each root; the root configures the engine and reads its state for the DI context.
+ *
+ * Must be called in an injection context (it runs effects and `inject`-based hooks).
+ *
+ * @internal Not part of the public API — exported only for the autocomplete entry; may change without notice.
+ */
+declare function useComboboxEngine(config: ComboboxEngineConfig): {
+    listId: string;
+    labelId: Signal<string | undefined>;
+    setLabelId(id: string | undefined): void;
+    inputElement: Signal<HTMLInputElement | null>;
+    setInputElement(el: HTMLInputElement | null): void;
+    inputLayout: Signal<ComboboxInputLayout>;
+    setInputLayout(layout: ComboboxInputLayout): void;
+    openedByTouch: Signal<boolean>;
+    setOpenedByTouch(value: boolean): void;
+    popupMounted: Signal<boolean>;
+    setPopupMounted(value: boolean): void;
+    readonly triggerElement: HTMLElement | null;
+    setTrigger(el: HTMLElement | null): void;
+    orderedItems: Signal<ComboboxItemRef[]>;
+    visibleItems: Signal<ComboboxItemRef[]>;
+    visibleCount: Signal<number>;
+    filteredItems: Signal<readonly AcceptableValue[]>;
+    isVisible: (item: ComboboxItemRef) => boolean;
+    registerItem(item: ComboboxItemRef): void;
+    unregisterItem(item: ComboboxItemRef): void;
+    highlight: _radix_ng_primitives_core.ListHighlight<ComboboxItemRef>;
+    highlightedItem: Signal<ComboboxItemRef | null>;
+    highlightedIndex: Signal<number>;
+    activeId: Signal<string | undefined>;
+    itemId: (index: number) => string;
+    setHighlightReason(reason: ComboboxHighlightReason): void;
+    setPendingHighlightEdge(edge: "first" | "last" | "first-match" | null): void;
+    /** Transient inline-completion preview (autocomplete inline modes); `null` when inactive. */
+    inlinePreview: Signal<string | null>;
+    /** Suppress inline completion for the current edit (e.g. while a delete key is held). */
+    setSuppressInline(value: boolean): void;
+    /** Clear the inline preview synchronously (on select / clear / close, before the effect runs). */
+    clearInlinePreview(): void;
+    highlightNext(reason?: ComboboxHighlightReason): void;
+    highlightPrevious(reason?: ComboboxHighlightReason): void;
+    highlightNextColumn(reason?: ComboboxHighlightReason): void;
+    highlightPreviousColumn(reason?: ComboboxHighlightReason): 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;
+    transitionStatus: Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
+    registerTransitionElement: (element: HTMLElement) => () => void;
+    focusInput(): void;
+    selectInputText(): void;
+    /**
+     * Restore focus after a selection: the input when it sits outside the popup, otherwise the
+     * trigger. Skipped when the consumer moved focus during the `onValueChange` callback — pass the
+     * `document.activeElement` captured *before* the emit so we don't clobber a consumer's choice
+     * (e.g. focusing an external message field after inserting an emoji).
+     */
+    restoreFocusAfterSelect(previousActiveElement: Element | null): void;
+};
+
+/** The value a combobox can hold: a single value, an array (multiple mode), or nothing. */
+type ComboboxValue = AcceptableValue | AcceptableValue[];
+type RdxComboboxOpenChangeReason = 'trigger-press' | 'input-press' | 'list-navigation' | 'input-change' | 'input-clear' | 'item-press' | 'outside-press' | 'focus-out' | 'escape-key' | 'close-press' | 'cancel-open' | 'none';
+type RdxComboboxOpenChangeEventDetails = RdxCancelableChangeEventDetails<RdxComboboxOpenChangeReason>;
+interface RdxComboboxOpenChange {
+    open: boolean;
+    reason: RdxComboboxOpenChangeReason;
+    event: Event;
+    trigger: HTMLElement | undefined;
+    eventDetails: RdxComboboxOpenChangeEventDetails;
+}
+
 declare const context: () => {
     listId: string;
-    labelId: _angular_core.WritableSignal<string | undefined>;
+    labelId: _angular_core.Signal<string | undefined>;
     setLabelId: (id: string | undefined) => void;
-    dir: _angular_core.InputSignal<Direction>;
+    dir: _angular_core.Signal<Direction>;
     value: _angular_core.ModelSignal<ComboboxValue>;
     inputValue: _angular_core.ModelSignal<string>;
     open: _angular_core.ModelSignal<boolean>;
-    multiple: Signal<boolean>;
-    selectionMode: Signal<"none" | "single" | "multiple">;
-    disabledState: Signal<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: Signal<boolean>;
+    requiredState: _angular_core.Signal<boolean>;
     openOnInputClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
     modal: _angular_core.InputSignalWithTransform<boolean, unknown>;
     virtualized: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    filteredItems: Signal<readonly AcceptableValue[]>;
-    highlightedItem: Signal<ComboboxItemRef | null>;
-    highlightedIndex: Signal<number>;
-    activeId: Signal<string | undefined>;
+    grid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    filteredItems: _angular_core.Signal<readonly AcceptableValue[]>;
+    highlightedItem: _angular_core.Signal<ComboboxItemRef | null>;
+    highlightedIndex: _angular_core.Signal<number>;
+    activeId: _angular_core.Signal<string | undefined>;
     itemId: (index: number) => string;
     isKeyboardActive: () => boolean;
     setKeyboardActive: (value: boolean) => void;
-    transitionStatus: Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
+    transitionStatus: _angular_core.Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
     registerTransitionElement: (element: HTMLElement) => () => void;
-    visibleCount: Signal<number>;
+    visibleCount: _angular_core.Signal<number>;
     isVisible: (item: ComboboxItemRef) => boolean;
     isSelected: (value: AcceptableValue) => boolean;
     registerItem: (item: ComboboxItemRef) => void;
@@ -93,23 +232,34 @@ declare const context: () => {
     highlight: _radix_ng_primitives_core.ListHighlight<ComboboxItemRef>;
     highlightNext: () => void;
     highlightPrevious: () => void;
+    highlightNextColumn: () => void;
+    highlightPreviousColumn: () => void;
     highlightFirst: () => void;
     highlightLast: () => void;
     highlightIndex: (index: number, reason: ComboboxHighlightReason) => void;
     setHighlight: (item: ComboboxItemRef, reason: ComboboxHighlightReason) => void;
     clearHighlight: () => void;
-    inputElement: Signal<HTMLInputElement | null>;
+    highlightItemOnHover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    keepHighlight: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    inputElement: _angular_core.Signal<HTMLInputElement | null>;
     setInputElement: (el: HTMLInputElement | null) => void;
-    registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+    inputLayout: _angular_core.Signal<ComboboxInputLayout>;
+    setInputLayout: (layout: 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: () => void;
-    openForBrowse: () => void;
-    closePopup: (revert?: boolean) => void;
+    openPopup: (reason?: RdxComboboxOpenChangeReason, event?: Event) => boolean;
+    openForBrowse: (reason?: RdxComboboxOpenChangeReason, event?: Event) => void;
+    closePopup: (revert?: boolean, reason?: RdxComboboxOpenChangeReason, event?: Event) => void;
     setInputValue: (value: string) => void;
-    openAndHighlight: (edge: "first" | "last") => void;
-    select: (item: ComboboxItemRef) => void;
-    selectIndex: (index: number) => void;
-    selectHighlighted: () => void;
+    openAndHighlight: (edge: "first" | "last", reason?: RdxComboboxOpenChangeReason, event?: Event) => void;
+    navigateByKeyboard: (direction: 1 | -1, event?: Event) => void;
+    select: (item: ComboboxItemRef, event?: Event) => void;
+    selectIndex: (index: number, event?: Event) => void;
+    selectHighlighted: (event?: Event) => void;
     clearSelection: () => void;
     removeValue: (value: AcceptableValue) => void;
     removeLastValue: () => void;
@@ -121,30 +271,32 @@ declare const context: () => {
 type RdxComboboxRootContext = ReturnType<typeof context>;
 declare const injectComboboxRootContext: _radix_ng_primitives_core.InjectContext<{
     listId: string;
-    labelId: _angular_core.WritableSignal<string | undefined>;
+    labelId: _angular_core.Signal<string | undefined>;
     setLabelId: (id: string | undefined) => void;
-    dir: _angular_core.InputSignal<Direction>;
+    dir: _angular_core.Signal<Direction>;
     value: _angular_core.ModelSignal<ComboboxValue>;
     inputValue: _angular_core.ModelSignal<string>;
     open: _angular_core.ModelSignal<boolean>;
-    multiple: Signal<boolean>;
-    selectionMode: Signal<"none" | "single" | "multiple">;
-    disabledState: Signal<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: Signal<boolean>;
+    requiredState: _angular_core.Signal<boolean>;
     openOnInputClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
     modal: _angular_core.InputSignalWithTransform<boolean, unknown>;
     virtualized: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    filteredItems: Signal<readonly AcceptableValue[]>;
-    highlightedItem: Signal<ComboboxItemRef | null>;
-    highlightedIndex: Signal<number>;
-    activeId: Signal<string | undefined>;
+    grid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    filteredItems: _angular_core.Signal<readonly AcceptableValue[]>;
+    highlightedItem: _angular_core.Signal<ComboboxItemRef | null>;
+    highlightedIndex: _angular_core.Signal<number>;
+    activeId: _angular_core.Signal<string | undefined>;
     itemId: (index: number) => string;
     isKeyboardActive: () => boolean;
     setKeyboardActive: (value: boolean) => void;
-    transitionStatus: Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
+    transitionStatus: _angular_core.Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
     registerTransitionElement: (element: HTMLElement) => () => void;
-    visibleCount: Signal<number>;
+    visibleCount: _angular_core.Signal<number>;
     isVisible: (item: ComboboxItemRef) => boolean;
     isSelected: (value: AcceptableValue) => boolean;
     registerItem: (item: ComboboxItemRef) => void;
@@ -152,23 +304,34 @@ declare const injectComboboxRootContext: _radix_ng_primitives_core.InjectContext
     highlight: _radix_ng_primitives_core.ListHighlight<ComboboxItemRef>;
     highlightNext: () => void;
     highlightPrevious: () => void;
+    highlightNextColumn: () => void;
+    highlightPreviousColumn: () => void;
     highlightFirst: () => void;
     highlightLast: () => void;
     highlightIndex: (index: number, reason: ComboboxHighlightReason) => void;
     setHighlight: (item: ComboboxItemRef, reason: ComboboxHighlightReason) => void;
     clearHighlight: () => void;
-    inputElement: Signal<HTMLInputElement | null>;
+    highlightItemOnHover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    keepHighlight: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    inputElement: _angular_core.Signal<HTMLInputElement | null>;
     setInputElement: (el: HTMLInputElement | null) => void;
-    registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+    inputLayout: _angular_core.Signal<ComboboxInputLayout>;
+    setInputLayout: (layout: 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: () => void;
-    openForBrowse: () => void;
-    closePopup: (revert?: boolean) => void;
+    openPopup: (reason?: RdxComboboxOpenChangeReason, event?: Event) => boolean;
+    openForBrowse: (reason?: RdxComboboxOpenChangeReason, event?: Event) => void;
+    closePopup: (revert?: boolean, reason?: RdxComboboxOpenChangeReason, event?: Event) => void;
     setInputValue: (value: string) => void;
-    openAndHighlight: (edge: "first" | "last") => void;
-    select: (item: ComboboxItemRef) => void;
-    selectIndex: (index: number) => void;
-    selectHighlighted: () => void;
+    openAndHighlight: (edge: "first" | "last", reason?: RdxComboboxOpenChangeReason, event?: Event) => void;
+    navigateByKeyboard: (direction: 1 | -1, event?: Event) => void;
+    select: (item: ComboboxItemRef, event?: Event) => void;
+    selectIndex: (index: number, event?: Event) => void;
+    selectHighlighted: (event?: Event) => void;
     clearSelection: () => void;
     removeValue: (value: AcceptableValue) => void;
     removeLastValue: () => void;
@@ -179,30 +342,32 @@ declare const injectComboboxRootContext: _radix_ng_primitives_core.InjectContext
 }>;
 declare const provideComboboxRootContext: (useFactory: () => {
     listId: string;
-    labelId: _angular_core.WritableSignal<string | undefined>;
+    labelId: _angular_core.Signal<string | undefined>;
     setLabelId: (id: string | undefined) => void;
-    dir: _angular_core.InputSignal<Direction>;
+    dir: _angular_core.Signal<Direction>;
     value: _angular_core.ModelSignal<ComboboxValue>;
     inputValue: _angular_core.ModelSignal<string>;
     open: _angular_core.ModelSignal<boolean>;
-    multiple: Signal<boolean>;
-    selectionMode: Signal<"none" | "single" | "multiple">;
-    disabledState: Signal<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: Signal<boolean>;
+    requiredState: _angular_core.Signal<boolean>;
     openOnInputClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
     modal: _angular_core.InputSignalWithTransform<boolean, unknown>;
     virtualized: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    filteredItems: Signal<readonly AcceptableValue[]>;
-    highlightedItem: Signal<ComboboxItemRef | null>;
-    highlightedIndex: Signal<number>;
-    activeId: Signal<string | undefined>;
+    grid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    filteredItems: _angular_core.Signal<readonly AcceptableValue[]>;
+    highlightedItem: _angular_core.Signal<ComboboxItemRef | null>;
+    highlightedIndex: _angular_core.Signal<number>;
+    activeId: _angular_core.Signal<string | undefined>;
     itemId: (index: number) => string;
     isKeyboardActive: () => boolean;
     setKeyboardActive: (value: boolean) => void;
-    transitionStatus: Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
+    transitionStatus: _angular_core.Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
     registerTransitionElement: (element: HTMLElement) => () => void;
-    visibleCount: Signal<number>;
+    visibleCount: _angular_core.Signal<number>;
     isVisible: (item: ComboboxItemRef) => boolean;
     isSelected: (value: AcceptableValue) => boolean;
     registerItem: (item: ComboboxItemRef) => void;
@@ -210,23 +375,34 @@ declare const provideComboboxRootContext: (useFactory: () => {
     highlight: _radix_ng_primitives_core.ListHighlight<ComboboxItemRef>;
     highlightNext: () => void;
     highlightPrevious: () => void;
+    highlightNextColumn: () => void;
+    highlightPreviousColumn: () => void;
     highlightFirst: () => void;
     highlightLast: () => void;
     highlightIndex: (index: number, reason: ComboboxHighlightReason) => void;
     setHighlight: (item: ComboboxItemRef, reason: ComboboxHighlightReason) => void;
     clearHighlight: () => void;
-    inputElement: Signal<HTMLInputElement | null>;
+    highlightItemOnHover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    keepHighlight: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    inputElement: _angular_core.Signal<HTMLInputElement | null>;
     setInputElement: (el: HTMLInputElement | null) => void;
-    registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+    inputLayout: _angular_core.Signal<ComboboxInputLayout>;
+    setInputLayout: (layout: 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: () => void;
-    openForBrowse: () => void;
-    closePopup: (revert?: boolean) => void;
+    openPopup: (reason?: RdxComboboxOpenChangeReason, event?: Event) => boolean;
+    openForBrowse: (reason?: RdxComboboxOpenChangeReason, event?: Event) => void;
+    closePopup: (revert?: boolean, reason?: RdxComboboxOpenChangeReason, event?: Event) => void;
     setInputValue: (value: string) => void;
-    openAndHighlight: (edge: "first" | "last") => void;
-    select: (item: ComboboxItemRef) => void;
-    selectIndex: (index: number) => void;
-    selectHighlighted: () => void;
+    openAndHighlight: (edge: "first" | "last", reason?: RdxComboboxOpenChangeReason, event?: Event) => void;
+    navigateByKeyboard: (direction: 1 | -1, event?: Event) => void;
+    select: (item: ComboboxItemRef, event?: Event) => void;
+    selectIndex: (index: number, event?: Event) => void;
+    selectHighlighted: (event?: Event) => void;
     clearSelection: () => void;
     removeValue: (value: AcceptableValue) => void;
     removeLastValue: () => void;
@@ -236,14 +412,17 @@ declare const provideComboboxRootContext: (useFactory: () => {
     markAsTouched: () => void;
 }) => _angular_core.Provider;
 /**
- * Root of a Combobox — a filterable select. Owns selection, input text, open state, filtering, and
- * highlight-model navigation, and exposes them to the parts through {@link RdxComboboxRootContext}.
- * Implements `ControlValueAccessor` for forms.
+ * Root of a Combobox — a filterable select. Owns selection, input text, open state, and the forms
+ * integration, and delegates filtering / highlight-model navigation / the open-close transition to the
+ * shared {@link useComboboxEngine} (ADR 0014). Exposes everything to the parts through
+ * {@link RdxComboboxRootContext}. Implements `ControlValueAccessor`.
  *
  * @group Components
  */
 declare class RdxComboboxRoot implements ControlValueAccessor {
     private readonly injector;
+    /** Per-popup floating root context (ADR 0015) — `open` / `triggers` / reference for the dismissal engine. */
+    readonly floatingContext: RdxFloatingRootContext;
     /** Selected value(s). A single value in single mode, an array in `multiple` mode. */
     readonly value: _angular_core.ModelSignal<ComboboxValue>;
     /** Initial value when uncontrolled. */
@@ -262,17 +441,18 @@ declare class RdxComboboxRoot implements ControlValueAccessor {
      */
     readonly selectionMode: _angular_core.InputSignal<"none" | "single" | "multiple" | undefined>;
     /** Resolved selection mode. */
-    readonly mode: Signal<"none" | "single" | "multiple">;
+    readonly mode: _angular_core.Signal<"none" | "single" | "multiple">;
     /** Whether the combobox is in multiple-selection mode. */
-    readonly multiple: Signal<boolean>;
+    readonly multiple: _angular_core.Signal<boolean>;
     /** In `'none'` mode, whether pressing an item fills the input with its label. */
     readonly fillInputOnItemPress: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Text direction. */
-    readonly dir: _angular_core.InputSignal<Direction>;
+    readonly dirInput: _angular_core.InputSignal<Direction | undefined>;
+    readonly dir: _angular_core.Signal<Direction>;
     /** Whether the combobox is disabled. */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Whether the combobox is read-only. */
-    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the combobox is read-only. Base UI prop name. */
+    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. */
@@ -280,12 +460,24 @@ declare class RdxComboboxRoot implements ControlValueAccessor {
     /**
      * Auto-highlight behavior:
      * - `false` (default): never auto-highlight;
-     * - `true` / `'input-change'`: highlight the first match as the query changes;
+     * - `true` (also the bare `autoHighlight` attribute) / `'input-change'`: highlight the first match as the query changes;
      * - `'always'`: keep the first navigable item highlighted whenever the popup is open.
      */
-    readonly autoHighlight: _angular_core.InputSignal<boolean | "always" | "input-change">;
+    readonly autoHighlight: _angular_core.InputSignalWithTransform<boolean | "input-change" | "always", BooleanInput>;
     /** Resolved auto-highlight mode. */
-    readonly autoHighlightMode: Signal<"always" | "input-change" | "off">;
+    readonly autoHighlightMode: _angular_core.Signal<"off" | "input-change" | "always">;
+    /**
+     * Whether moving the pointer over an item highlights it. `true` (default) paints `data-highlighted`
+     * on hover; `false` suppresses hover-driven highlight entirely, letting CSS `:hover` stay distinct
+     * from the `data-highlighted` (keyboard) state. Clicking an item still selects it.
+     */
+    readonly highlightItemOnHover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether a pointer-driven highlight is kept when the cursor leaves the list. `false` (default)
+     * clears the highlight on pointer-leave; `true` retains the last hovered item highlighted. Keyboard
+     * navigation and auto-highlight are unaffected.
+     */
+    readonly keepHighlight: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether clicking the input opens the popup. */
     readonly openOnInputClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the popup is modal: locks page scroll and makes outside content inert while open. */
@@ -314,8 +506,14 @@ declare class RdxComboboxRoot implements ControlValueAccessor {
      * items outside the rendered window are not skipped by keyboard navigation.
      */
     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>;
+    /**
+     * Whether the list is laid out as a 2D grid: `ArrowUp`/`ArrowDown` move between rows (keeping the
+     * column), `ArrowLeft`/`ArrowRight` move within a row. Wrap items in `RdxComboboxRow`; the list
+     * switches to `role="grid"`. Not supported together with {@link virtualized}.
+     */
+    readonly grid: _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 a value to its display label. Defaults to the matching item's text. */
     readonly itemToStringLabel: _angular_core.InputSignal<((value: AcceptableValue) => string) | undefined>;
     /** Emits when the selection changes. */
@@ -323,7 +521,7 @@ declare class RdxComboboxRoot implements ControlValueAccessor {
     /** Emits when the input text changes. */
     readonly onInputValueChange: _angular_core.OutputEmitterRef<string>;
     /** 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. In virtualized mode, use `index` to call the virtualizer's `scrollToIndex`.
@@ -331,123 +529,92 @@ declare class RdxComboboxRoot implements ControlValueAccessor {
     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: 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>;
     private readonly cvaDisabled;
-    readonly disabledState: Signal<boolean>;
-    readonly requiredState: Signal<boolean>;
-    private readonly defaultFilter;
+    readonly disabledState: _angular_core.Signal<boolean>;
+    readonly requiredState: _angular_core.Signal<boolean>;
+    private readonly preventUnmountOnClose;
+    readonly present: _angular_core.Signal<boolean>;
     /**
      * Whether the input text is a fresh user query rather than the current selection's label. While
      * `false` (just opened, or showing a selected label), the list is unfiltered so the user can
      * browse; it flips `true` on the first keystroke.
      */
     private readonly typed;
-    private readonly _items;
-    /** Registered items, sorted into DOM order. */
-    readonly orderedItems: Signal<ComboboxItemRef[]>;
-    /** Matching items in DOM order, capped at `limit`. The set of items the list shows. */
-    readonly visibleItems: Signal<ComboboxItemRef[]>;
-    private readonly visibleSet;
-    /**
-     * The filtered item values an external virtualizer should render (the analogue of Base UI's
-     * `useFilteredItems`). Driven by {@link items} when provided (virtualized mode), capped by
-     * {@link limit}; otherwise mirrors the values of the mounted {@link visibleItems}.
-     */
-    readonly filteredItems: Signal<readonly AcceptableValue[]>;
-    readonly visibleCount: Signal<number>;
-    readonly highlight: _radix_ng_primitives_core.ListHighlight<ComboboxItemRef>;
-    readonly highlightedItem: 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: Signal<string | undefined>;
-    /** Edge to highlight once the list has mounted (items register asynchronously after opening). */
-    private readonly pendingHighlightEdge;
+    /** The active query: the typed text once the user starts typing, otherwise empty (browse mode). */
+    private readonly query;
+    /** Built-in filtering always applies for combobox (the `none` filter is handled inside the engine). */
+    private readonly filteringEnabled;
+    /** Combobox never inline-completes (that's an autocomplete mode). */
+    private readonly noInline;
+    /** The shared engine: item registry, filtering, highlight navigation, and the open-close transition. */
+    private readonly engine;
+    /** The list element id referenced by `aria-controls` / `aria-activedescendant` (engine-backed). */
+    get listId(): string;
+    /** The currently highlighted item (engine-backed; read by parts and tests). */
+    get highlightedItem(): _angular_core.Signal<ComboboxItemRef | null>;
+    /** Number of items the list currently shows (engine-backed). */
+    get visibleCount(): _angular_core.Signal<number>;
+    /** The filtered item values an external virtualizer should render (engine-backed). */
+    get filteredItems(): _angular_core.Signal<readonly AcceptableValue[]>;
+    /** Highlighted index into {@link filteredItems} in virtualized mode (engine-backed). */
+    get highlightedIndex(): _angular_core.Signal<number>;
+    /** The active option's id for `aria-activedescendant` (engine-backed). */
+    get activeId(): _angular_core.Signal<string | undefined>;
     private onChange?;
     private onTouched?;
     constructor();
     /** 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;
-    private keyboardActive;
-    isKeyboardActive(): boolean;
-    setKeyboardActive(value: boolean): void;
+    openAndHighlight(edge: 'first' | 'last', reason?: RdxComboboxOpenChangeReason, event?: Event): void;
+    /**
+     * Keyboard list navigation shared by the input and the chips: opens the popup and highlights the
+     * leading/trailing edge when closed, otherwise steps the highlight. `direction` is `1` (down) or
+     * `-1` (up). Centralized so the input and chip key handlers can't drift apart.
+     */
+    navigateByKeyboard(direction: 1 | -1, event?: Event): void;
     isSelected(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 the query as a fresh user query). */
     setInputValue(value: string): void;
     /** Sets the input text programmatically (a selection label / revert) — not a user query. */
     private setLabel;
-    /** Selects all input text so the next keystroke replaces a stale selection label. */
-    selectInputText(): void;
     /** Resets the input text to the current selection's label (single mode) or empty. */
     private revertInputValue;
     labelFor(value: AcceptableValue): string;
-    /** Filter/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;
+    handleSelect(item: ComboboxItemRef, event?: Event): void;
     /** Selects the filtered item at `index` (virtualized mode). The label comes from {@link labelFor}. */
-    selectIndex(index: number): void;
+    selectIndex(index: number, event?: Event): void;
     /** Commits a selection from a resolved value/label, independent of whether a DOM item exists. */
     private handleSelectValue;
     /** Requests submit of the closest form when `submitOnItemClick` is enabled. */
     private maybeSubmit;
-    selectHighlighted(): void;
-    highlightNext(reason?: ComboboxHighlightReason): void;
-    highlightPrevious(reason?: ComboboxHighlightReason): void;
-    highlightFirst(reason?: ComboboxHighlightReason): void;
-    highlightLast(reason?: ComboboxHighlightReason): void;
-    /** Highlights a specific index in virtualized mode (e.g. pointer hover). Ignored if out of range. */
-    highlightIndex(index: number, reason: ComboboxHighlightReason): void;
-    /** Highlights a DOM-ref item (non-virtualized pointer hover). */
-    setHighlight(item: ComboboxItemRef, reason: ComboboxHighlightReason): void;
-    /** Clears whichever highlight model is active. */
-    clearHighlightState(): void;
-    /** Steps the virtualized highlight index by `direction`, wrapping when {@link loopFocus}. */
-    private stepIndex;
+    selectHighlighted(event?: Event): void;
     clearSelection(): void;
     removeValue(value: AcceptableValue): void;
     removeLastValue(): void;
-    /** The trigger element, used as a focus fallback when the input lives inside the popup. */
-    triggerElement: HTMLElement | null;
     focusInput(): void;
-    /**
-     * Restores focus after a selection closes the popup, so the keyboard can reopen it. When the
-     * input lives inside the popup it is about to unmount, so focus goes to the trigger instead;
-     * otherwise it returns to the input. Done synchronously while the input is still in the DOM.
-     */
-    restoreFocusAfterSelect(): void;
     private chipsFocusLast;
     /** Registered by `RdxComboboxChips` so the input can hand keyboard focus to the chips. */
     registerChipsNav(fn: (() => boolean) | null): void;
     /** Moves focus to the last chip, if any. Returns whether a chip was focused. */
     focusLastChip(): boolean;
     markAsTouched(): void;
+    /**
+     * The single guarded value-mutation point for all user-driven changes (selection toggle, Clear,
+     * chip removal, Backspace). Read-only / disabled comboboxes never mutate here — programmatic form
+     * writes go through {@link writeValue}, which is intentionally not guarded. (ADR 0014, Finding 1.)
+     */
     private commitValue;
+    private createOpenChangeEvent;
+    private resolveOpenChangeTrigger;
     writeValue(value: ComboboxValue | null): void;
     registerOnChange(fn: (value: ComboboxValue | null) => void): void;
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxRoot, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxRoot, "[rdxComboboxRoot]", ["rdxComboboxRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "inputValue": { "alias": "inputValue"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "multipleInput": { "alias": "multiple"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "fillInputOnItemPress": { "alias": "fillInputOnItemPress"; "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; }; "openOnInputClick": { "alias": "openOnInputClick"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "submitOnItemClick": { "alias": "submitOnItemClick"; "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; }; "itemToStringLabel": { "alias": "itemToStringLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "inputValue": "inputValueChange"; "open": "openChange"; "onValueChange": "onValueChange"; "onInputValueChange": "onInputValueChange"; "onOpenChange": "onOpenChange"; "onItemHighlighted": "onItemHighlighted"; "onOpenChangeComplete": "onOpenChangeComplete"; }, never, never, true, [{ directive: typeof i1.RdxPopper; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxRoot, "[rdxComboboxRoot]", ["rdxComboboxRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "inputValue": { "alias": "inputValue"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "multipleInput": { "alias": "multiple"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "fillInputOnItemPress": { "alias": "fillInputOnItemPress"; "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; }; "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; }; "grid": { "alias": "grid"; "required": false; "isSignal": true; }; "isItemEqualToValue": { "alias": "isItemEqualToValue"; "required": false; "isSignal": true; }; "itemToStringLabel": { "alias": "itemToStringLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "inputValue": "inputValueChange"; "open": "openChange"; "onValueChange": "onValueChange"; "onInputValueChange": "onInputValueChange"; "onOpenChange": "onOpenChange"; "onItemHighlighted": "onItemHighlighted"; "onOpenChangeComplete": "onOpenChangeComplete"; }, never, never, true, [{ directive: typeof i1.RdxPopper; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -473,12 +640,13 @@ declare class RdxComboboxLabel {
 declare class RdxComboboxInput {
     protected readonly rootContext: {
         listId: string;
-        labelId: _angular_core.WritableSignal<string | undefined>;
+        labelId: _angular_core.Signal<string | undefined>;
         setLabelId: (id: string | undefined) => void;
-        dir: _angular_core.InputSignal<_radix_ng_primitives_core.Direction>;
+        dir: _angular_core.Signal<_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>;
@@ -487,6 +655,7 @@ declare class RdxComboboxInput {
         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_core.AcceptableValue[]>;
         highlightedItem: _angular_core.Signal<_radix_ng_primitives_combobox.ComboboxItemRef | null>;
         highlightedIndex: _angular_core.Signal<number>;
@@ -504,23 +673,34 @@ declare class RdxComboboxInput {
         highlight: _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;
-        registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+        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: () => void;
-        openForBrowse: () => void;
-        closePopup: (revert?: boolean) => 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") => void;
-        select: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
-        selectIndex: (index: number) => void;
-        selectHighlighted: () => 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_core.AcceptableValue) => void;
         removeLastValue: () => void;
@@ -548,13 +728,103 @@ declare class RdxComboboxInput {
     onInput(event: Event): void;
     onCompositionEnd(event: CompositionEvent): void;
     private commitInput;
-    onClick(): void;
+    onClick(event: MouseEvent): void;
     onFocus(): void;
     onBlur(): void;
     onKeydown(event: KeyboardEvent): void;
+    /**
+     * From the very start of the input in `multiple` mode, step into the chips. The key that points
+     * toward the chips is direction-aware: `ArrowLeft` in LTR, `ArrowRight` in RTL.
+     */
+    private maybeStepIntoChips;
     protected readonly dataAttr: (value: boolean) => "" | undefined;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxInput, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxInput, "input[rdxComboboxInput]", ["rdxComboboxInput"], { "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 i1$1.RdxDismissableLayerBranch; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxInput, "input[rdxComboboxInput]", ["rdxComboboxInput"], { "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 i1$1.RdxFloatingInsideElement; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Optional wrapper around the input and its adornments (icon, clear, trigger). Mirrors the combobox
+ * state via `data-*` so the whole group can be styled together (focus ring, disabled, etc.).
+ *
+ * @group Components
+ */
+declare class RdxComboboxInputGroup {
+    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 a value is selected (a non-empty array in multiple mode, or a non-nullish single value). */
+    protected readonly filled: _angular_core.Signal<boolean>;
+    protected readonly dataAttr: (value: boolean) => "" | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxInputGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxInputGroup, "[rdxComboboxInputGroup]", ["rdxComboboxInputGroup"], {}, {}, never, never, true, never>;
 }
 
 /**
@@ -581,19 +851,30 @@ declare class RdxComboboxValue {
 }
 
 /**
- * Toggles the combobox popup. Carries `tabindex="-1"` so it never steals focus from the input.
+ * Toggles the combobox popup. Its semantics depend on the layout (Base UI's `inputInsidePopup`):
+ *
+ * - **Input outside the popup** (default): a `tabindex="-1"` toggle button (`aria-haspopup="listbox"`)
+ *   that never steals focus from the input — `Tab` lands directly on the input.
+ * - **Input inside the popup** (e.g. a command palette / emoji picker): the trigger becomes the primary
+ *   `role="combobox"` control — `tabindex="0"` (reachable via `Tab`), `aria-haspopup="dialog"`, and
+ *   `ArrowDown`/`ArrowUp` open the popup (which moves focus to the inner input and highlights an item).
+ *
+ * The trigger stays `Tab`-reachable by default and is demoted to `tabindex="-1"` only once an input is
+ * detected *outside* the popup — so a trigger whose input lives in a not-yet-opened popup is focusable
+ * from the first render (`inputLayout` is `unknown` until that input mounts).
  *
  * @group Components
  */
 declare class RdxComboboxTrigger {
     protected readonly rootContext: {
         listId: string;
-        labelId: _angular_core.WritableSignal<string | undefined>;
+        labelId: _angular_core.Signal<string | undefined>;
         setLabelId: (id: string | undefined) => void;
-        dir: _angular_core.InputSignal<_radix_ng_primitives_types_radix_ng_primitives_core.Direction>;
+        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>;
@@ -602,6 +883,7 @@ declare class RdxComboboxTrigger {
         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>;
@@ -619,23 +901,34 @@ declare class RdxComboboxTrigger {
         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;
-        registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+        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: () => void;
-        openForBrowse: () => void;
-        closePopup: (revert?: boolean) => 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") => void;
-        select: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
-        selectIndex: (index: number) => void;
-        selectHighlighted: () => 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;
@@ -646,9 +939,11 @@ declare class RdxComboboxTrigger {
     };
     private readonly element;
     constructor();
-    onClick(): void;
+    onPointerDown(event: PointerEvent): void;
+    onClick(event: MouseEvent): void;
+    onKeydown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxTrigger, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxTrigger, "button[rdxComboboxTrigger]", ["rdxComboboxTrigger"], {}, {}, never, never, true, [{ directive: typeof i1$1.RdxDismissableLayerBranch; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxTrigger, "button[rdxComboboxTrigger]", ["rdxComboboxTrigger"], {}, {}, never, never, true, [{ directive: typeof i1$1.RdxFloatingInsideElement; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -669,12 +964,13 @@ declare class RdxComboboxIcon {
 declare class RdxComboboxClear {
     protected readonly rootContext: {
         listId: string;
-        labelId: _angular_core.WritableSignal<string | undefined>;
+        labelId: _angular_core.Signal<string | undefined>;
         setLabelId: (id: string | undefined) => void;
-        dir: _angular_core.InputSignal<_radix_ng_primitives_types_radix_ng_primitives_core.Direction>;
+        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>;
@@ -683,6 +979,7 @@ declare class RdxComboboxClear {
         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>;
@@ -700,23 +997,34 @@ declare class RdxComboboxClear {
         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;
-        registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+        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: () => void;
-        openForBrowse: () => void;
-        closePopup: (revert?: boolean) => 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") => void;
-        select: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
-        selectIndex: (index: number) => void;
-        selectHighlighted: () => 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;
@@ -725,31 +1033,52 @@ declare class RdxComboboxClear {
         labelFor: (value: _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue) => string;
         markAsTouched: () => void;
     };
+    /** Disables just this clear button (in addition to the combobox's own disabled / read-only state). */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    /**
+     * Whether there is nothing to clear, mirroring Base UI's visibility rule: in `none` mode the
+     * button tracks the input text (a pure search field has no selection), otherwise it tracks the
+     * selected value(s).
+     */
     protected readonly isEmpty: _angular_core.Signal<boolean>;
+    onPointerDown(event: MouseEvent): void;
     onClick(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxClear, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxClear, "button[rdxComboboxClear]", ["rdxComboboxClear"], {}, {}, never, never, true, [{ directive: typeof i1$1.RdxDismissableLayerBranch; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxClear, "button[rdxComboboxClear]", ["rdxComboboxClear"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxFloatingInsideElement; inputs: {}; outputs: {}; }]>;
 }
 
 /**
- * Teleports the popup into a container (default `document.body`).
+ * Structural directive that teleports the combobox popup into a container (default `document.body`)
+ * while the combobox is open, and keeps it mounted until any CSS exit `@keyframes` finishes.
+ *
+ * Apply it with the `*` microsyntax on the positioner —
+ * `<div *rdxComboboxPortal rdxComboboxPositioner>` — or as an explicit `<ng-template rdxComboboxPortal>`.
+ * For a custom container use the explicit form with `[container]`.
  *
  * @group Components
  */
 declare class RdxComboboxPortal {
+    /**
+     * Optional container to portal the content into. Defaults to `document.body`. Declared here (and
+     * forwarded to the composed {@link RdxPortalPresence}) so the autocomplete portal can re-expose it
+     * through its own `hostDirectives`.
+     */
+    readonly container: _angular_core.InputSignal<RdxPortalContainer | undefined>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxPortal, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxPortal, "[rdxComboboxPortal]", ["rdxComboboxPortal"], {}, {}, never, never, true, [{ directive: typeof i1$2.RdxPortal; inputs: { "container": "container"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxPortal, "ng-template[rdxComboboxPortal]", ["rdxComboboxPortal"], { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$2.RdxPortalPresence; inputs: { "container": "container"; }; outputs: {}; }]>;
 }
-
 /**
- * Wraps the popup template in {@link RdxPresenceDirective} so it mounts/unmounts with the open state
- * and can run enter/leave animations.
+ * Dev-mode guard: `rdxComboboxPortal` used to be an attribute directive on a `<div>`. It is now
+ * structural, so the old `<div rdxComboboxPortal>` markup would silently stop portaling — fail loudly
+ * instead.
  *
  * @group Components
  */
-declare class RdxComboboxPortalPresence {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxPortalPresence, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxPortalPresence, "ng-template[rdxComboboxPortalPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1$3.RdxPresenceDirective; inputs: {}; outputs: {}; }]>;
+declare class RdxComboboxPortalMisuseGuard {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxPortalMisuseGuard, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxPortalMisuseGuard, "[rdxComboboxPortal]:not(ng-template)", never, {}, {}, never, never, true, never>;
 }
 
 /**
@@ -762,12 +1091,13 @@ declare class RdxComboboxPortalPresence {
 declare class RdxComboboxBackdrop {
     protected readonly rootContext: {
         listId: string;
-        labelId: _angular_core.WritableSignal<string | undefined>;
+        labelId: _angular_core.Signal<string | undefined>;
         setLabelId: (id: string | undefined) => void;
-        dir: _angular_core.InputSignal<_radix_ng_primitives_types_radix_ng_primitives_core.Direction>;
+        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>;
@@ -776,6 +1106,7 @@ declare class RdxComboboxBackdrop {
         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>;
@@ -793,23 +1124,34 @@ declare class RdxComboboxBackdrop {
         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;
-        registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+        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: () => void;
-        openForBrowse: () => void;
-        closePopup: (revert?: boolean) => 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") => void;
-        select: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
-        selectIndex: (index: number) => void;
-        selectHighlighted: () => 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;
@@ -823,25 +1165,20 @@ declare class RdxComboboxBackdrop {
 }
 
 /**
- * Positions the popup relative to the input anchor using the popper engine. Re-exposes the popper
- * positioning inputs.
+ * Positions the combobox 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 combobox's Base UI-aligned defaults through the
+ * config provider. `provideRdxPopperContentWrapper` re-wires the `useExisting` alias + context that
+ * the popup and arrow resolve (Angular does not inherit a base directive's `providers`).
  *
  * @group Components
  */
-declare class RdxComboboxPositioner {
-    readonly side: _angular_core.InputSignal<"top" | "right" | "bottom" | "left">;
-    readonly sideOffset: _angular_core.InputSignalWithTransform<number, unknown>;
-    readonly align: _angular_core.InputSignal<"center" | "start" | "end">;
-    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 RdxComboboxPositioner extends RdxPopperContentWrapper {
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxPositioner, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxPositioner, "[rdxComboboxPositioner]", ["rdxComboboxPositioner"], { "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.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<RdxComboboxPositioner, "[rdxComboboxPositioner]", ["rdxComboboxPositioner"], {}, {}, never, never, true, never>;
 }
 
 /**
@@ -853,12 +1190,13 @@ declare class RdxComboboxPositioner {
 declare class RdxComboboxPopup {
     protected readonly rootContext: {
         listId: string;
-        labelId: _angular_core.WritableSignal<string | undefined>;
+        labelId: _angular_core.Signal<string | undefined>;
         setLabelId: (id: string | undefined) => void;
-        dir: _angular_core.InputSignal<_radix_ng_primitives_core.Direction>;
+        dir: _angular_core.Signal<_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>;
@@ -867,6 +1205,7 @@ declare class RdxComboboxPopup {
         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_core.AcceptableValue[]>;
         highlightedItem: _angular_core.Signal<_radix_ng_primitives_combobox.ComboboxItemRef | null>;
         highlightedIndex: _angular_core.Signal<number>;
@@ -884,23 +1223,34 @@ declare class RdxComboboxPopup {
         highlight: _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;
-        registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+        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: () => void;
-        openForBrowse: () => void;
-        closePopup: (revert?: boolean) => 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") => void;
-        select: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
-        selectIndex: (index: number) => void;
-        selectHighlighted: () => 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_core.AcceptableValue) => void;
         removeLastValue: () => void;
@@ -909,12 +1259,20 @@ declare class RdxComboboxPopup {
         labelFor: (value: _radix_ng_primitives_core.AcceptableValue) => string;
         markAsTouched: () => void;
     };
-    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 intentionally parked on the popup to keep
+     * the Android virtual keyboard closed.
+     */
+    onFocusIn(event: FocusEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxPopup, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxPopup, "[rdxComboboxPopup]", ["rdxComboboxPopup"], {}, {}, never, never, true, [{ directive: typeof i1.RdxPopperContent; inputs: {}; outputs: {}; }, { directive: typeof i1$1.RdxDismissableLayer; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxPopup, "[rdxComboboxPopup]", ["rdxComboboxPopup"], {}, {}, never, never, true, [{ directive: typeof i1.RdxPopperContent; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_core.RdxFloatingNodeRegistration; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -929,19 +1287,22 @@ declare class RdxComboboxArrow {
 }
 
 /**
- * The listbox container for options. Carries the id referenced by the input's `aria-controls`.
+ * The listbox container for options. Carries the id referenced by the input's `aria-controls`, exposes
+ * `data-empty` while no options match the current query (Base UI's `ComboboxList` empty state), and
+ * switches its `role` to `grid` when the root has `grid` enabled.
  *
  * @group Components
  */
 declare class RdxComboboxList {
     protected readonly rootContext: {
         listId: string;
-        labelId: _angular_core.WritableSignal<string | undefined>;
+        labelId: _angular_core.Signal<string | undefined>;
         setLabelId: (id: string | undefined) => void;
-        dir: _angular_core.InputSignal<_radix_ng_primitives_types_radix_ng_primitives_core.Direction>;
+        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>;
@@ -950,6 +1311,7 @@ declare class RdxComboboxList {
         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>;
@@ -967,23 +1329,34 @@ declare class RdxComboboxList {
         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;
-        registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+        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: () => void;
-        openForBrowse: () => void;
-        closePopup: (revert?: boolean) => 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") => void;
-        select: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
-        selectIndex: (index: number) => void;
-        selectHighlighted: () => 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;
@@ -992,28 +1365,41 @@ declare class RdxComboboxList {
         labelFor: (value: _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue) => string;
         markAsTouched: () => void;
     };
+    onKeydown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxList, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxList, "[rdxComboboxList]", ["rdxComboboxList"], {}, {}, never, never, true, never>;
 }
 
+/**
+ * A row in a grid-layout combobox 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 `[rdxComboboxRow]` ancestor.
+ *
+ * @group Components
+ */
+declare class RdxComboboxRow {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxRow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxRow, "[rdxComboboxRow]", ["rdxComboboxRow"], {}, {}, never, never, true, never>;
+}
+
 declare const itemContext: () => {
-    isSelected: _angular_core.Signal<boolean>;
-    isHighlighted: _angular_core.Signal<boolean>;
+    isSelected: Signal<boolean>;
+    isHighlighted: Signal<boolean>;
     disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    value: _angular_core.InputSignal<AcceptableValue>;
+    value: Signal<AcceptableValue>;
 };
 type RdxComboboxItemContext = ReturnType<typeof itemContext>;
 declare const injectComboboxItemContext: _radix_ng_primitives_core.InjectContext<{
-    isSelected: _angular_core.Signal<boolean>;
-    isHighlighted: _angular_core.Signal<boolean>;
+    isSelected: Signal<boolean>;
+    isHighlighted: Signal<boolean>;
     disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    value: _angular_core.InputSignal<AcceptableValue>;
+    value: Signal<AcceptableValue>;
 }>;
 declare const provideComboboxItemContext: (useFactory: () => {
-    isSelected: _angular_core.Signal<boolean>;
-    isHighlighted: _angular_core.Signal<boolean>;
+    isSelected: Signal<boolean>;
+    isHighlighted: Signal<boolean>;
     disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    value: _angular_core.InputSignal<AcceptableValue>;
+    value: Signal<AcceptableValue>;
 }) => _angular_core.Provider;
 /**
  * A selectable option. Registers itself with the root for filtering and navigation. Highlight is
@@ -1038,19 +1424,34 @@ declare class RdxComboboxItem implements ComboboxItemRef {
     readonly index: _angular_core.InputSignal<number | undefined>;
     protected readonly virtualized: _angular_core.InputSignalWithTransform<boolean, unknown>;
     private readonly autoTextValue;
-    readonly textValue: _angular_core.Signal<string>;
+    readonly textValue: Signal<string>;
     /** Host id: deterministic per-index in virtualized mode, otherwise a generated unique id. */
-    protected readonly elementId: _angular_core.Signal<string>;
-    protected readonly ariaSetSize: _angular_core.Signal<number | undefined>;
-    protected readonly ariaPosInSet: _angular_core.Signal<number | undefined>;
-    readonly isVisible: _angular_core.Signal<boolean>;
-    readonly isSelected: _angular_core.Signal<boolean>;
-    readonly isHighlighted: _angular_core.Signal<boolean>;
+    protected readonly elementId: Signal<string>;
+    protected readonly ariaSetSize: Signal<number | undefined>;
+    protected readonly ariaPosInSet: Signal<number | undefined>;
+    /** The nearest enclosing grid row, if any (drives the `gridcell` role). */
+    private readonly row;
+    /** `gridcell` only when actually inside a `RdxComboboxRow` of a grid list; otherwise `option`. */
+    protected readonly role: Signal<"gridcell" | "option">;
+    /**
+     * Whether selection is a meaningful concept here (Base UI's `selectable`). In `selectionMode="none"`
+     * (every autocomplete option, and a pure-search combobox) options carry no selection state, so
+     * `aria-selected` / `data-selected` are omitted entirely rather than rendered as `false`.
+     */
+    protected readonly selectable: Signal<boolean>;
+    readonly isVisible: Signal<boolean>;
+    readonly isSelected: Signal<boolean>;
+    readonly isHighlighted: Signal<boolean>;
     private readonly group;
     constructor();
+    private pointerDownStarted;
     onPointerDown(event: MouseEvent): void;
-    onPointerUp(): void;
+    onMouseDown(event: MouseEvent): void;
+    onMouseUp(event: MouseEvent): void;
+    onClick(event: MouseEvent): void;
+    private commitSelection;
     onPointerMove(): void;
+    onPointerLeave(event: PointerEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxItem, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxItem, "[rdxComboboxItem]", ["rdxComboboxItem"], { "value": { "alias": "value"; "required": true; "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>;
 }
@@ -1065,7 +1466,7 @@ declare class RdxComboboxItemIndicator {
         isSelected: _angular_core.Signal<boolean>;
         isHighlighted: _angular_core.Signal<boolean>;
         disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-        value: _angular_core.InputSignal<_radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue>;
+        value: _angular_core.Signal<_radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue>;
     };
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxItemIndicator, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxItemIndicator, "[rdxComboboxItemIndicator]", ["rdxComboboxItemIndicator"], {}, {}, never, never, true, never>;
@@ -1119,19 +1520,36 @@ declare class RdxComboboxGroupLabel {
 }
 
 /**
- * Shown only when no items match the current query.
+ * A visual separator between groups of options. Carries `role="separator"` with a horizontal
+ * orientation (it divides rows in a vertical list), so assistive tech announces the grouping break.
+ *
+ * @group Components
+ */
+declare class RdxComboboxSeparator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxSeparator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxSeparator, "[rdxComboboxSeparator]", ["rdxComboboxSeparator"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * A polite, atomic live region announcing the "no results" message. Mirrors Base UI: the element
+ * stays **mounted and visible at all times** so screen readers reliably announce the transition to
+ * empty — only its *content* is rendered conditionally (projected when nothing matches, removed
+ * otherwise). It must never be hidden/unmounted (`hidden`, `display:none`, `aria-hidden`, `@if`):
+ * pulling the region out of the accessibility tree at the same instant its text appears is exactly
+ * what suppresses the announcement.
  *
  * @group Components
  */
 declare class RdxComboboxEmpty {
     protected readonly rootContext: {
         listId: string;
-        labelId: _angular_core.WritableSignal<string | undefined>;
+        labelId: _angular_core.Signal<string | undefined>;
         setLabelId: (id: string | undefined) => void;
-        dir: _angular_core.InputSignal<_radix_ng_primitives_types_radix_ng_primitives_core.Direction>;
+        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>;
@@ -1140,6 +1558,7 @@ declare class RdxComboboxEmpty {
         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>;
@@ -1157,23 +1576,34 @@ declare class RdxComboboxEmpty {
         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;
-        registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+        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: () => void;
-        openForBrowse: () => void;
-        closePopup: (revert?: boolean) => 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") => void;
-        select: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
-        selectIndex: (index: number) => void;
-        selectHighlighted: () => 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;
@@ -1182,8 +1612,10 @@ declare class RdxComboboxEmpty {
         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<RdxComboboxEmpty, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxEmpty, "[rdxComboboxEmpty]", ["rdxComboboxEmpty"], {}, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RdxComboboxEmpty, "[rdxComboboxEmpty]", ["rdxComboboxEmpty"], {}, {}, never, ["*"], true, never>;
 }
 
 /**
@@ -1198,7 +1630,9 @@ declare class RdxComboboxStatus {
 
 /**
  * Container for the selected-value chips in `multiple` mode. Sits before the input and coordinates
- * arrow-key navigation across the chips (the chips themselves handle the key events).
+ * arrow-key navigation across the chips (the chips themselves handle the key events). Uses
+ * `role="toolbar"` (Base UI): it keeps NVDA in focus mode while arrow-navigating the chips, where a
+ * plain `list` would drop into browse mode.
  *
  * @group Components
  */
@@ -1211,7 +1645,7 @@ declare class RdxComboboxChips {
     /** Focuses the last chip. Returns whether there was one. */
     focusLast(): boolean;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxChips, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxChips, "[rdxComboboxChips]", ["rdxComboboxChips"], {}, {}, never, never, true, [{ directive: typeof i1$1.RdxDismissableLayerBranch; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxChips, "[rdxComboboxChips]", ["rdxComboboxChips"], {}, {}, never, never, true, [{ directive: typeof i1$1.RdxFloatingInsideElement; inputs: {}; outputs: {}; }]>;
 }
 
 declare const chipContext: () => {
@@ -1257,9 +1691,9 @@ declare class RdxComboboxChipRemove {
 declare const _importsCombobox: (typeof RdxComboboxAnchor)[];
 declare class RdxComboboxModule {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxComboboxModule, never, [typeof RdxComboboxRoot, typeof RdxComboboxAnchor, typeof RdxComboboxLabel, typeof RdxComboboxInput, typeof RdxComboboxValue, typeof RdxComboboxTrigger, typeof RdxComboboxIcon, typeof RdxComboboxClear, typeof RdxComboboxPortal, typeof RdxComboboxPortalPresence, typeof RdxComboboxBackdrop, typeof RdxComboboxPositioner, typeof RdxComboboxPopup, typeof RdxComboboxArrow, typeof RdxComboboxList, typeof RdxComboboxItem, typeof RdxComboboxItemIndicator, typeof RdxComboboxGroup, typeof RdxComboboxGroupLabel, typeof RdxComboboxEmpty, typeof RdxComboboxStatus, typeof RdxComboboxChips, typeof RdxComboboxChip, typeof RdxComboboxChipRemove], [typeof RdxComboboxRoot, typeof RdxComboboxAnchor, typeof RdxComboboxLabel, typeof RdxComboboxInput, typeof RdxComboboxValue, typeof RdxComboboxTrigger, typeof RdxComboboxIcon, typeof RdxComboboxClear, typeof RdxComboboxPortal, typeof RdxComboboxPortalPresence, typeof RdxComboboxBackdrop, typeof RdxComboboxPositioner, typeof RdxComboboxPopup, typeof RdxComboboxArrow, typeof RdxComboboxList, typeof RdxComboboxItem, typeof RdxComboboxItemIndicator, typeof RdxComboboxGroup, typeof RdxComboboxGroupLabel, typeof RdxComboboxEmpty, typeof RdxComboboxStatus, typeof RdxComboboxChips, typeof RdxComboboxChip, typeof RdxComboboxChipRemove]>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxComboboxModule, never, [typeof RdxComboboxRoot, typeof RdxComboboxAnchor, typeof RdxComboboxLabel, typeof RdxComboboxInput, typeof RdxComboboxInputGroup, typeof RdxComboboxValue, typeof RdxComboboxTrigger, typeof RdxComboboxIcon, typeof RdxComboboxClear, typeof RdxComboboxPortal, typeof RdxComboboxPortalMisuseGuard, typeof RdxComboboxBackdrop, typeof RdxComboboxPositioner, typeof RdxComboboxPopup, typeof RdxComboboxArrow, typeof RdxComboboxList, typeof RdxComboboxRow, typeof RdxComboboxItem, typeof RdxComboboxItemIndicator, typeof RdxComboboxGroup, typeof RdxComboboxGroupLabel, typeof RdxComboboxSeparator, typeof RdxComboboxEmpty, typeof RdxComboboxStatus, typeof RdxComboboxChips, typeof RdxComboboxChip, typeof RdxComboboxChipRemove], [typeof RdxComboboxRoot, typeof RdxComboboxAnchor, typeof RdxComboboxLabel, typeof RdxComboboxInput, typeof RdxComboboxInputGroup, typeof RdxComboboxValue, typeof RdxComboboxTrigger, typeof RdxComboboxIcon, typeof RdxComboboxClear, typeof RdxComboboxPortal, typeof RdxComboboxPortalMisuseGuard, typeof RdxComboboxBackdrop, typeof RdxComboboxPositioner, typeof RdxComboboxPopup, typeof RdxComboboxArrow, typeof RdxComboboxList, typeof RdxComboboxRow, typeof RdxComboboxItem, typeof RdxComboboxItemIndicator, typeof RdxComboboxGroup, typeof RdxComboboxGroupLabel, typeof RdxComboboxSeparator, typeof RdxComboboxEmpty, typeof RdxComboboxStatus, typeof RdxComboboxChips, typeof RdxComboboxChip, typeof RdxComboboxChipRemove]>;
     static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxComboboxModule>;
 }
 
-export { RdxComboboxAnchor, RdxComboboxArrow, RdxComboboxBackdrop, RdxComboboxChip, RdxComboboxChipRemove, RdxComboboxChips, RdxComboboxClear, RdxComboboxEmpty, RdxComboboxGroup, RdxComboboxGroupLabel, RdxComboboxIcon, RdxComboboxInput, RdxComboboxItem, RdxComboboxItemIndicator, RdxComboboxLabel, RdxComboboxList, RdxComboboxModule, RdxComboboxPopup, RdxComboboxPortal, RdxComboboxPortalPresence, RdxComboboxPositioner, RdxComboboxRoot, RdxComboboxStatus, RdxComboboxTrigger, RdxComboboxValue, _importsCombobox, injectComboboxChipContext, injectComboboxGroupContext, injectComboboxItemContext, injectComboboxRootContext, provideComboboxChipContext, provideComboboxGroupContext, provideComboboxItemContext, provideComboboxRootContext };
-export type { ComboboxFilter, ComboboxHighlightReason, ComboboxItemHighlightedDetails, ComboboxItemRef, ComboboxValue, RdxComboboxChipContext, RdxComboboxGroupContext, RdxComboboxItemContext, RdxComboboxRootContext };
+export { RdxComboboxAnchor, RdxComboboxArrow, RdxComboboxBackdrop, RdxComboboxChip, RdxComboboxChipRemove, RdxComboboxChips, RdxComboboxClear, RdxComboboxEmpty, RdxComboboxGroup, RdxComboboxGroupLabel, RdxComboboxIcon, RdxComboboxInput, RdxComboboxInputGroup, RdxComboboxItem, RdxComboboxItemIndicator, RdxComboboxLabel, RdxComboboxList, RdxComboboxModule, RdxComboboxPopup, RdxComboboxPortal, RdxComboboxPortalMisuseGuard, RdxComboboxPositioner, RdxComboboxRoot, RdxComboboxRow, RdxComboboxSeparator, RdxComboboxStatus, RdxComboboxTrigger, RdxComboboxValue, _importsCombobox, injectComboboxChipContext, injectComboboxGroupContext, injectComboboxItemContext, injectComboboxRootContext, provideComboboxChipContext, provideComboboxGroupContext, provideComboboxItemContext, provideComboboxRootContext, useComboboxEngine };
+export type { ComboboxFilter, ComboboxHighlightReason, ComboboxInputLayout, ComboboxItemHighlightedDetails, ComboboxItemRef, ComboboxValue, RdxComboboxChipContext, RdxComboboxGroupContext, RdxComboboxItemContext, RdxComboboxOpenChange, RdxComboboxOpenChangeEventDetails, RdxComboboxOpenChangeReason, RdxComboboxRootContext };