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

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

@@ -0,0 +1,1265 @@
+import * as _angular_core from '@angular/core';
+import { Signal, ElementRef } from '@angular/core';
+import * as i1 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 { 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';
+
+/**
+ * Optional positioning anchor for the popup. Put it on the element the popup should align to — for
+ * example a control that wraps chips + input in `multiple` mode. When present it takes precedence
+ * over the input (the popper resolves the first `RdxPopperAnchor` in DOM order, and this part sits
+ * above the input). When absent, the input itself is the anchor, which is ideal when the input fills
+ * the control.
+ *
+ * @group Components
+ */
+declare class RdxComboboxAnchor {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxAnchor, never>;
+    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.
+ */
+interface ComboboxItemRef {
+    /** The option's element id, exposed via `aria-activedescendant` when highlighted. */
+    readonly id: string;
+    /** The option's host element, used for DOM-order sorting. */
+    readonly element: HTMLElement;
+    /** The option's value. */
+    readonly value: Signal<AcceptableValue>;
+    /** The text matched against the query and written to the input on selection. */
+    readonly textValue: Signal<string>;
+    /** Whether the option is disabled. */
+    readonly disabled: Signal<boolean>;
+}
+/** A custom filter predicate: `(itemText, query) => matches`. */
+type ComboboxFilter = (itemText: string, query: string) => boolean;
+/** Why the highlight moved: keyboard navigation, pointer hover, or a programmatic change. */
+type ComboboxHighlightReason = 'keyboard' | 'pointer' | 'none';
+/** Payload of {@link RdxComboboxRoot.onItemHighlighted}. */
+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.
+     */
+    index: number;
+    /** What caused the highlight to move. */
+    reason: ComboboxHighlightReason;
+}
+declare const context: () => {
+    listId: string;
+    labelId: _angular_core.WritableSignal<string | undefined>;
+    setLabelId: (id: string | undefined) => void;
+    dir: _angular_core.InputSignal<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>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    requiredState: 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>;
+    itemId: (index: number) => string;
+    isKeyboardActive: () => boolean;
+    setKeyboardActive: (value: boolean) => void;
+    transitionStatus: Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
+    registerTransitionElement: (element: HTMLElement) => () => void;
+    visibleCount: Signal<number>;
+    isVisible: (item: ComboboxItemRef) => boolean;
+    isSelected: (value: AcceptableValue) => boolean;
+    registerItem: (item: ComboboxItemRef) => void;
+    unregisterItem: (item: ComboboxItemRef) => void;
+    highlight: _radix_ng_primitives_core.ListHighlight<ComboboxItemRef>;
+    highlightNext: () => void;
+    highlightPrevious: () => void;
+    highlightFirst: () => void;
+    highlightLast: () => void;
+    highlightIndex: (index: number, reason: ComboboxHighlightReason) => void;
+    setHighlight: (item: ComboboxItemRef, reason: ComboboxHighlightReason) => void;
+    clearHighlight: () => void;
+    inputElement: Signal<HTMLInputElement | null>;
+    setInputElement: (el: HTMLInputElement | null) => void;
+    registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+    focusInput: () => void;
+    openPopup: () => void;
+    openForBrowse: () => void;
+    closePopup: (revert?: boolean) => void;
+    setInputValue: (value: string) => void;
+    openAndHighlight: (edge: "first" | "last") => void;
+    select: (item: ComboboxItemRef) => void;
+    selectIndex: (index: number) => void;
+    selectHighlighted: () => void;
+    clearSelection: () => void;
+    removeValue: (value: AcceptableValue) => void;
+    removeLastValue: () => void;
+    registerChipsNav: (fn: (() => boolean) | null) => void;
+    focusLastChip: () => boolean;
+    labelFor: (value: AcceptableValue) => string;
+    markAsTouched: () => void;
+};
+type RdxComboboxRootContext = ReturnType<typeof context>;
+declare const injectComboboxRootContext: _radix_ng_primitives_core.InjectContext<{
+    listId: string;
+    labelId: _angular_core.WritableSignal<string | undefined>;
+    setLabelId: (id: string | undefined) => void;
+    dir: _angular_core.InputSignal<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>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    requiredState: 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>;
+    itemId: (index: number) => string;
+    isKeyboardActive: () => boolean;
+    setKeyboardActive: (value: boolean) => void;
+    transitionStatus: Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
+    registerTransitionElement: (element: HTMLElement) => () => void;
+    visibleCount: Signal<number>;
+    isVisible: (item: ComboboxItemRef) => boolean;
+    isSelected: (value: AcceptableValue) => boolean;
+    registerItem: (item: ComboboxItemRef) => void;
+    unregisterItem: (item: ComboboxItemRef) => void;
+    highlight: _radix_ng_primitives_core.ListHighlight<ComboboxItemRef>;
+    highlightNext: () => void;
+    highlightPrevious: () => void;
+    highlightFirst: () => void;
+    highlightLast: () => void;
+    highlightIndex: (index: number, reason: ComboboxHighlightReason) => void;
+    setHighlight: (item: ComboboxItemRef, reason: ComboboxHighlightReason) => void;
+    clearHighlight: () => void;
+    inputElement: Signal<HTMLInputElement | null>;
+    setInputElement: (el: HTMLInputElement | null) => void;
+    registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+    focusInput: () => void;
+    openPopup: () => void;
+    openForBrowse: () => void;
+    closePopup: (revert?: boolean) => void;
+    setInputValue: (value: string) => void;
+    openAndHighlight: (edge: "first" | "last") => void;
+    select: (item: ComboboxItemRef) => void;
+    selectIndex: (index: number) => void;
+    selectHighlighted: () => void;
+    clearSelection: () => void;
+    removeValue: (value: AcceptableValue) => void;
+    removeLastValue: () => void;
+    registerChipsNav: (fn: (() => boolean) | null) => void;
+    focusLastChip: () => boolean;
+    labelFor: (value: AcceptableValue) => string;
+    markAsTouched: () => void;
+}>;
+declare const provideComboboxRootContext: (useFactory: () => {
+    listId: string;
+    labelId: _angular_core.WritableSignal<string | undefined>;
+    setLabelId: (id: string | undefined) => void;
+    dir: _angular_core.InputSignal<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>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    requiredState: 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>;
+    itemId: (index: number) => string;
+    isKeyboardActive: () => boolean;
+    setKeyboardActive: (value: boolean) => void;
+    transitionStatus: Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
+    registerTransitionElement: (element: HTMLElement) => () => void;
+    visibleCount: Signal<number>;
+    isVisible: (item: ComboboxItemRef) => boolean;
+    isSelected: (value: AcceptableValue) => boolean;
+    registerItem: (item: ComboboxItemRef) => void;
+    unregisterItem: (item: ComboboxItemRef) => void;
+    highlight: _radix_ng_primitives_core.ListHighlight<ComboboxItemRef>;
+    highlightNext: () => void;
+    highlightPrevious: () => void;
+    highlightFirst: () => void;
+    highlightLast: () => void;
+    highlightIndex: (index: number, reason: ComboboxHighlightReason) => void;
+    setHighlight: (item: ComboboxItemRef, reason: ComboboxHighlightReason) => void;
+    clearHighlight: () => void;
+    inputElement: Signal<HTMLInputElement | null>;
+    setInputElement: (el: HTMLInputElement | null) => void;
+    registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+    focusInput: () => void;
+    openPopup: () => void;
+    openForBrowse: () => void;
+    closePopup: (revert?: boolean) => void;
+    setInputValue: (value: string) => void;
+    openAndHighlight: (edge: "first" | "last") => void;
+    select: (item: ComboboxItemRef) => void;
+    selectIndex: (index: number) => void;
+    selectHighlighted: () => void;
+    clearSelection: () => void;
+    removeValue: (value: AcceptableValue) => void;
+    removeLastValue: () => void;
+    registerChipsNav: (fn: (() => boolean) | null) => void;
+    focusLastChip: () => boolean;
+    labelFor: (value: AcceptableValue) => string;
+    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.
+ *
+ * @group Components
+ */
+declare class RdxComboboxRoot implements ControlValueAccessor {
+    private readonly injector;
+    /** Selected value(s). A single value in single mode, an array in `multiple` mode. */
+    readonly value: _angular_core.ModelSignal<ComboboxValue>;
+    /** Initial value when uncontrolled. */
+    readonly defaultValue: _angular_core.InputSignal<ComboboxValue | undefined>;
+    /** The text currently in the input. */
+    readonly inputValue: _angular_core.ModelSignal<string>;
+    /** Whether the popup is open. */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** Initial open state when uncontrolled. */
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether multiple values can be selected. Shorthand for `selectionMode="multiple"`. */
+    readonly multipleInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Selection behavior. `'single'` / `'multiple'` commit a value; `'none'` filters without
+     * selecting (a pure search/command UI). Defaults from the `multiple` shorthand.
+     */
+    readonly selectionMode: _angular_core.InputSignal<"none" | "single" | "multiple" | undefined>;
+    /** Resolved selection mode. */
+    readonly mode: Signal<"none" | "single" | "multiple">;
+    /** Whether the combobox is in multiple-selection mode. */
+    readonly multiple: 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>;
+    /** 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 a value is required (for forms). */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether keyboard navigation wraps at the list boundaries. */
+    readonly loopFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Auto-highlight behavior:
+     * - `false` (default): never auto-highlight;
+     * - `true` / `'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">;
+    /** Resolved auto-highlight mode. */
+    readonly autoHighlightMode: Signal<"always" | "input-change" | "off">;
+    /** 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. */
+    readonly modal: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether selecting an item requests submit of the closest form. */
+    readonly submitOnItemClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Filter applied to items against the input query.
+     * - `undefined` (default): locale-aware "contains" via {@link useFilter};
+     * - a function: custom matching;
+     * - `null`: built-in filtering disabled (the consumer controls which items exist).
+     */
+    readonly filter: _angular_core.InputSignal<ComboboxFilter | null | undefined>;
+    /** Maximum number of matching items to show. `-1` (default) means no limit. */
+    readonly limit: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * The full set of item values, used as the source of truth for filtering and navigation in
+     * {@link virtualized} mode (where only a window of `RdxComboboxItem` is mounted). The filtered
+     * subset is exposed as {@link filteredItems} for an external virtualizer to render.
+     */
+    readonly items: _angular_core.InputSignal<readonly AcceptableValue[] | undefined>;
+    /**
+     * Whether the list is externally virtualized — only a window of items is rendered, so navigation
+     * runs over {@link items}/{@link filteredItems} by index instead of over mounted DOM elements.
+     * Requires {@link items}, and {@link itemToStringLabel} for selection labels/filter text. Disabled
+     * 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>;
+    /** 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. */
+    readonly onValueChange: _angular_core.OutputEmitterRef<ComboboxValue>;
+    /** 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>;
+    /**
+     * 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`.
+     */
+    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;
+    /**
+     * 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;
+    private onChange?;
+    private onTouched?;
+    constructor();
+    /** Opens the popup for browsing (resets the query to "pristine" and selects the input text). */
+    openForBrowse(): void;
+    /** Opens the popup and highlights the given edge once the list mounts. */
+    openAndHighlight(edge: 'first' | 'last'): void;
+    /** Whether the item matches the active query (ignores the `limit` cap). */
+    private matchesFilter;
+    /** Whether the item is shown in the list (matches the query and is within `limit`). */
+    isVisible(item: ComboboxItemRef): boolean;
+    private keyboardActive;
+    isKeyboardActive(): boolean;
+    setKeyboardActive(value: boolean): void;
+    isSelected(value: AcceptableValue): boolean;
+    registerItem(item: ComboboxItemRef): void;
+    unregisterItem(item: ComboboxItemRef): void;
+    setOpen(open: boolean): void;
+    closePopup(revert?: boolean): void;
+    /** Updates the input text from user typing (marks 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;
+    /** Selects the filtered item at `index` (virtualized mode). The label comes from {@link labelFor}. */
+    selectIndex(index: number): 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;
+    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;
+    private commitValue;
+    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: {}; }]>;
+}
+
+/**
+ * An accessible label for the combobox. Registers its id so the input (and trigger) reference it via
+ * `aria-labelledby`.
+ *
+ * @group Components
+ */
+declare class RdxComboboxLabel {
+    private readonly rootContext;
+    readonly id: string;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxLabel, "[rdxComboboxLabel]", ["rdxComboboxLabel"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * The combobox text input. Holds DOM focus at all times; the highlighted option is referenced via
+ * `aria-activedescendant`. Integrates with Field for labeling, description, and validation state.
+ *
+ * @group Components
+ */
+declare class RdxComboboxInput {
+    protected readonly rootContext: {
+        listId: string;
+        labelId: _angular_core.WritableSignal<string | undefined>;
+        setLabelId: (id: string | undefined) => void;
+        dir: _angular_core.InputSignal<_radix_ng_primitives_core.Direction>;
+        value: _angular_core.ModelSignal<_radix_ng_primitives_combobox.ComboboxValue>;
+        inputValue: _angular_core.ModelSignal<string>;
+        open: _angular_core.ModelSignal<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>;
+        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>;
+        activeId: _angular_core.Signal<string | undefined>;
+        itemId: (index: number) => string;
+        isKeyboardActive: () => boolean;
+        setKeyboardActive: (value: boolean) => void;
+        transitionStatus: _angular_core.Signal<_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_core.AcceptableValue) => boolean;
+        registerItem: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
+        unregisterItem: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
+        highlight: _radix_ng_primitives_core.ListHighlight<_radix_ng_primitives_combobox.ComboboxItemRef>;
+        highlightNext: () => void;
+        highlightPrevious: () => 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;
+        inputElement: _angular_core.Signal<HTMLInputElement | null>;
+        setInputElement: (el: HTMLInputElement | null) => void;
+        registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+        focusInput: () => void;
+        openPopup: () => void;
+        openForBrowse: () => void;
+        closePopup: (revert?: boolean) => void;
+        setInputValue: (value: string) => void;
+        openAndHighlight: (edge: "first" | "last") => void;
+        select: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
+        selectIndex: (index: number) => void;
+        selectHighlighted: () => void;
+        clearSelection: () => void;
+        removeValue: (value: _radix_ng_primitives_core.AcceptableValue) => void;
+        removeLastValue: () => void;
+        registerChipsNav: (fn: (() => boolean) | null) => void;
+        focusLastChip: () => boolean;
+        labelFor: (value: _radix_ng_primitives_core.AcceptableValue) => string;
+        markAsTouched: () => void;
+    };
+    private readonly element;
+    private readonly fieldRootContext;
+    /** The input id; Field labels and descriptions reference it for accessible relationships. */
+    readonly id: _angular_core.InputSignal<string>;
+    /** Marks the input as invalid independently of any Field state. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly invalidState: _angular_core.Signal<boolean>;
+    protected readonly disabledState: _angular_core.Signal<boolean>;
+    protected readonly requiredState: _angular_core.Signal<boolean>;
+    protected readonly filledState: _angular_core.Signal<boolean>;
+    protected readonly focusedState: _angular_core.Signal<boolean>;
+    protected readonly isEmptyValue: _angular_core.Signal<boolean>;
+    protected readonly describedBy: _angular_core.Signal<string | undefined>;
+    constructor();
+    /** Whether an IME composition is in progress (CJK). While composing, don't filter or select. */
+    protected composing: boolean;
+    onInput(event: Event): void;
+    onCompositionEnd(event: CompositionEvent): void;
+    private commitInput;
+    onClick(): void;
+    onFocus(): void;
+    onBlur(): void;
+    onKeydown(event: KeyboardEvent): void;
+    protected readonly dataAttr: (value: boolean) => "" | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<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: {}; }]>;
+}
+
+/**
+ * Renders the current selection's label(s) — typically inside a {@link RdxComboboxTrigger} for a
+ * select-like control. Read `slotText()` in the template, or compose your own from `selectedLabels()`.
+ * Exposes `data-placeholder` while nothing is selected.
+ *
+ * @example
+ * <span #value="rdxComboboxValue" rdxComboboxValue placeholder="Select…">{{ value.slotText() }}</span>
+ *
+ * @group Components
+ */
+declare class RdxComboboxValue {
+    private readonly rootContext;
+    /** Text shown when there is no selection. */
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    /** The label(s) of the current selection, resolved via the root's `itemToStringLabel`/items. */
+    readonly selectedLabels: _angular_core.Signal<string[]>;
+    readonly isEmpty: _angular_core.Signal<boolean>;
+    /** The selection joined for display, or the `placeholder` when empty. */
+    readonly slotText: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxValue, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxValue, "[rdxComboboxValue]", ["rdxComboboxValue"], { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Toggles the combobox popup. Carries `tabindex="-1"` so it never steals focus from the input.
+ *
+ * @group Components
+ */
+declare class RdxComboboxTrigger {
+    protected readonly rootContext: {
+        listId: string;
+        labelId: _angular_core.WritableSignal<string | undefined>;
+        setLabelId: (id: string | undefined) => void;
+        dir: _angular_core.InputSignal<_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>;
+        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>;
+        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;
+        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;
+        inputElement: _angular_core.Signal<HTMLInputElement | null>;
+        setInputElement: (el: HTMLInputElement | null) => void;
+        registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+        focusInput: () => void;
+        openPopup: () => void;
+        openForBrowse: () => void;
+        closePopup: (revert?: boolean) => void;
+        setInputValue: (value: string) => void;
+        openAndHighlight: (edge: "first" | "last") => void;
+        select: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
+        selectIndex: (index: number) => void;
+        selectHighlighted: () => 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;
+    };
+    private readonly element;
+    constructor();
+    onClick(): 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: {}; }]>;
+}
+
+/**
+ * Decorative icon inside the trigger. Hidden from assistive technology.
+ *
+ * @group Components
+ */
+declare class RdxComboboxIcon {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxIcon, "[rdxComboboxIcon]", ["rdxComboboxIcon"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Clears the current selection and the input text. Hidden when there is nothing to clear.
+ *
+ * @group Components
+ */
+declare class RdxComboboxClear {
+    protected readonly rootContext: {
+        listId: string;
+        labelId: _angular_core.WritableSignal<string | undefined>;
+        setLabelId: (id: string | undefined) => void;
+        dir: _angular_core.InputSignal<_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>;
+        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>;
+        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;
+        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;
+        inputElement: _angular_core.Signal<HTMLInputElement | null>;
+        setInputElement: (el: HTMLInputElement | null) => void;
+        registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+        focusInput: () => void;
+        openPopup: () => void;
+        openForBrowse: () => void;
+        closePopup: (revert?: boolean) => void;
+        setInputValue: (value: string) => void;
+        openAndHighlight: (edge: "first" | "last") => void;
+        select: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
+        selectIndex: (index: number) => void;
+        selectHighlighted: () => 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;
+    };
+    protected readonly isEmpty: _angular_core.Signal<boolean>;
+    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: {}; }]>;
+}
+
+/**
+ * Teleports the popup into a container (default `document.body`).
+ *
+ * @group Components
+ */
+declare class RdxComboboxPortal {
+    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: {}; }]>;
+}
+
+/**
+ * Wraps the popup template in {@link RdxPresenceDirective} so it mounts/unmounts with the open state
+ * and can run enter/leave animations.
+ *
+ * @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: {}; }]>;
+}
+
+/**
+ * An overlay rendered beneath the popup in `modal` mode. Place it inside the portal/presence; style
+ * it `position: fixed; inset: 0`. Give it `pointer-events: auto` so a click on it dismisses the popup
+ * (with `modal`, the rest of the page is inert). Exposes `data-open` / `data-closed` for animation.
+ *
+ * @group Components
+ */
+declare class RdxComboboxBackdrop {
+    protected readonly rootContext: {
+        listId: string;
+        labelId: _angular_core.WritableSignal<string | undefined>;
+        setLabelId: (id: string | undefined) => void;
+        dir: _angular_core.InputSignal<_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>;
+        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>;
+        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;
+        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;
+        inputElement: _angular_core.Signal<HTMLInputElement | null>;
+        setInputElement: (el: HTMLInputElement | null) => void;
+        registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+        focusInput: () => void;
+        openPopup: () => void;
+        openForBrowse: () => void;
+        closePopup: (revert?: boolean) => void;
+        setInputValue: (value: string) => void;
+        openAndHighlight: (edge: "first" | "last") => void;
+        select: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
+        selectIndex: (index: number) => void;
+        selectHighlighted: () => 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;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxBackdrop, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxBackdrop, "[rdxComboboxBackdrop]", ["rdxComboboxBackdrop"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Positions the popup relative to the input anchor using the popper engine. Re-exposes the popper
+ * positioning inputs.
+ *
+ * @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">;
+    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: {}; }]>;
+}
+
+/**
+ * The popup surface. Composes the popper content (for `data-side` / `data-align`) and a dismissable
+ * layer for outside-dismiss. It does **not** trap focus — focus stays in the input throughout.
+ *
+ * @group Components
+ */
+declare class RdxComboboxPopup {
+    protected readonly rootContext: {
+        listId: string;
+        labelId: _angular_core.WritableSignal<string | undefined>;
+        setLabelId: (id: string | undefined) => void;
+        dir: _angular_core.InputSignal<_radix_ng_primitives_core.Direction>;
+        value: _angular_core.ModelSignal<_radix_ng_primitives_combobox.ComboboxValue>;
+        inputValue: _angular_core.ModelSignal<string>;
+        open: _angular_core.ModelSignal<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>;
+        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>;
+        activeId: _angular_core.Signal<string | undefined>;
+        itemId: (index: number) => string;
+        isKeyboardActive: () => boolean;
+        setKeyboardActive: (value: boolean) => void;
+        transitionStatus: _angular_core.Signal<_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_core.AcceptableValue) => boolean;
+        registerItem: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
+        unregisterItem: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
+        highlight: _radix_ng_primitives_core.ListHighlight<_radix_ng_primitives_combobox.ComboboxItemRef>;
+        highlightNext: () => void;
+        highlightPrevious: () => 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;
+        inputElement: _angular_core.Signal<HTMLInputElement | null>;
+        setInputElement: (el: HTMLInputElement | null) => void;
+        registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+        focusInput: () => void;
+        openPopup: () => void;
+        openForBrowse: () => void;
+        closePopup: (revert?: boolean) => void;
+        setInputValue: (value: string) => void;
+        openAndHighlight: (edge: "first" | "last") => void;
+        select: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
+        selectIndex: (index: number) => void;
+        selectHighlighted: () => void;
+        clearSelection: () => void;
+        removeValue: (value: _radix_ng_primitives_core.AcceptableValue) => void;
+        removeLastValue: () => void;
+        registerChipsNav: (fn: (() => boolean) | null) => void;
+        focusLastChip: () => boolean;
+        labelFor: (value: _radix_ng_primitives_core.AcceptableValue) => string;
+        markAsTouched: () => void;
+    };
+    private readonly dismissableLayer;
+    private readonly popper;
+    private readonly element;
+    constructor();
+    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: {}; }]>;
+}
+
+/**
+ * An optional arrow that points from the popup to the anchor. Composes the popper arrow, which keeps
+ * it aligned as the popup flips sides.
+ *
+ * @group Components
+ */
+declare class RdxComboboxArrow {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxArrow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxArrow, "[rdxComboboxArrow]", ["rdxComboboxArrow"], {}, {}, never, never, true, [{ directive: typeof i1.RdxPopperArrow; inputs: { "width": "width"; "height": "height"; }; outputs: {}; }]>;
+}
+
+/**
+ * The listbox container for options. Carries the id referenced by the input's `aria-controls`.
+ *
+ * @group Components
+ */
+declare class RdxComboboxList {
+    protected readonly rootContext: {
+        listId: string;
+        labelId: _angular_core.WritableSignal<string | undefined>;
+        setLabelId: (id: string | undefined) => void;
+        dir: _angular_core.InputSignal<_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>;
+        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>;
+        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;
+        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;
+        inputElement: _angular_core.Signal<HTMLInputElement | null>;
+        setInputElement: (el: HTMLInputElement | null) => void;
+        registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+        focusInput: () => void;
+        openPopup: () => void;
+        openForBrowse: () => void;
+        closePopup: (revert?: boolean) => void;
+        setInputValue: (value: string) => void;
+        openAndHighlight: (edge: "first" | "last") => void;
+        select: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
+        selectIndex: (index: number) => void;
+        selectHighlighted: () => 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;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxList, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxList, "[rdxComboboxList]", ["rdxComboboxList"], {}, {}, never, never, true, never>;
+}
+
+declare const itemContext: () => {
+    isSelected: _angular_core.Signal<boolean>;
+    isHighlighted: _angular_core.Signal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    value: _angular_core.InputSignal<AcceptableValue>;
+};
+type RdxComboboxItemContext = ReturnType<typeof itemContext>;
+declare const injectComboboxItemContext: _radix_ng_primitives_core.InjectContext<{
+    isSelected: _angular_core.Signal<boolean>;
+    isHighlighted: _angular_core.Signal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    value: _angular_core.InputSignal<AcceptableValue>;
+}>;
+declare const provideComboboxItemContext: (useFactory: () => {
+    isSelected: _angular_core.Signal<boolean>;
+    isHighlighted: _angular_core.Signal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    value: _angular_core.InputSignal<AcceptableValue>;
+}) => _angular_core.Provider;
+/**
+ * A selectable option. Registers itself with the root for filtering and navigation. Highlight is
+ * virtual (`data-highlighted` + `aria-activedescendant` on the input) — items never take DOM focus.
+ *
+ * @group Components
+ */
+declare class RdxComboboxItem implements ComboboxItemRef {
+    private readonly rootContext;
+    readonly element: HTMLElement;
+    readonly id: string;
+    /** The option's value. */
+    readonly value: _angular_core.InputSignal<AcceptableValue>;
+    /** Explicit text matched against the query. Defaults to the element's text content. */
+    readonly textValueInput: _angular_core.InputSignal<string>;
+    /** Whether the option is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The option's index in the list. Required in virtualized mode — it drives the deterministic id
+     * (for `aria-activedescendant`), highlight matching, and selection when only a window is mounted.
+     */
+    readonly index: _angular_core.InputSignal<number | undefined>;
+    protected readonly virtualized: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly autoTextValue;
+    readonly textValue: _angular_core.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>;
+    private readonly group;
+    constructor();
+    onPointerDown(event: MouseEvent): void;
+    onPointerUp(): void;
+    onPointerMove(): 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>;
+}
+
+/**
+ * Renders only when its item is selected (e.g. a checkmark).
+ *
+ * @group Components
+ */
+declare class RdxComboboxItemIndicator {
+    protected readonly itemContext: {
+        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>;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxItemIndicator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxItemIndicator, "[rdxComboboxItemIndicator]", ["rdxComboboxItemIndicator"], {}, {}, never, never, true, never>;
+}
+
+declare const groupContext: () => {
+    labelId: _angular_core.WritableSignal<string | undefined>;
+    registerItem: (item: ComboboxItemRef) => void;
+    unregisterItem: (item: ComboboxItemRef) => void;
+};
+type RdxComboboxGroupContext = ReturnType<typeof groupContext>;
+declare const injectComboboxGroupContext: _radix_ng_primitives_core.InjectContext<{
+    labelId: _angular_core.WritableSignal<string | undefined>;
+    registerItem: (item: ComboboxItemRef) => void;
+    unregisterItem: (item: ComboboxItemRef) => void;
+}>;
+declare const provideComboboxGroupContext: (useFactory: () => {
+    labelId: _angular_core.WritableSignal<string | undefined>;
+    registerItem: (item: ComboboxItemRef) => void;
+    unregisterItem: (item: ComboboxItemRef) => void;
+}) => _angular_core.Provider;
+/**
+ * Groups related options under a shared label. Hides itself when all of its items are filtered out,
+ * so a group heading never lingers above an empty section.
+ *
+ * @group Components
+ */
+declare class RdxComboboxGroup {
+    private readonly rootContext;
+    readonly labelId: _angular_core.WritableSignal<string | undefined>;
+    private readonly items;
+    protected readonly hasItems: _angular_core.Signal<boolean>;
+    protected readonly hasVisibleItems: _angular_core.Signal<boolean>;
+    registerItem(item: ComboboxItemRef): void;
+    unregisterItem(item: ComboboxItemRef): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxGroup, "[rdxComboboxGroup]", ["rdxComboboxGroup"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Accessible label for a {@link RdxComboboxGroup}. Wires itself up via `aria-labelledby`.
+ *
+ * @group Components
+ */
+declare class RdxComboboxGroupLabel {
+    private readonly groupContext;
+    readonly id: string;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxGroupLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxGroupLabel, "[rdxComboboxGroupLabel]", ["rdxComboboxGroupLabel"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Shown only when no items match the current query.
+ *
+ * @group Components
+ */
+declare class RdxComboboxEmpty {
+    protected readonly rootContext: {
+        listId: string;
+        labelId: _angular_core.WritableSignal<string | undefined>;
+        setLabelId: (id: string | undefined) => void;
+        dir: _angular_core.InputSignal<_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>;
+        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>;
+        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;
+        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;
+        inputElement: _angular_core.Signal<HTMLInputElement | null>;
+        setInputElement: (el: HTMLInputElement | null) => void;
+        registerTrigger: (el: HTMLElement | null) => HTMLElement | null;
+        focusInput: () => void;
+        openPopup: () => void;
+        openForBrowse: () => void;
+        closePopup: (revert?: boolean) => void;
+        setInputValue: (value: string) => void;
+        openAndHighlight: (edge: "first" | "last") => void;
+        select: (item: _radix_ng_primitives_combobox.ComboboxItemRef) => void;
+        selectIndex: (index: number) => void;
+        selectHighlighted: () => 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;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxEmpty, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxEmpty, "[rdxComboboxEmpty]", ["rdxComboboxEmpty"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * A polite live region for async status (loading, result counts) announced without moving focus.
+ *
+ * @group Components
+ */
+declare class RdxComboboxStatus {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxStatus, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxStatus, "[rdxComboboxStatus]", ["rdxComboboxStatus"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * 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).
+ *
+ * @group Components
+ */
+declare class RdxComboboxChips {
+    private readonly host;
+    private readonly rootContext;
+    constructor();
+    /** The chip elements in DOM order. */
+    getChips(): HTMLElement[];
+    /** 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: {}; }]>;
+}
+
+declare const chipContext: () => {
+    value: _angular_core.InputSignal<AcceptableValue>;
+};
+type RdxComboboxChipContext = ReturnType<typeof chipContext>;
+declare const injectComboboxChipContext: _radix_ng_primitives_core.InjectContext<{
+    value: _angular_core.InputSignal<AcceptableValue>;
+}>;
+declare const provideComboboxChipContext: (useFactory: () => {
+    value: _angular_core.InputSignal<AcceptableValue>;
+}) => _angular_core.Provider;
+/**
+ * A single selected-value chip. Provide its `value` so {@link RdxComboboxChipRemove} can deselect it.
+ * Chips are focusable and navigable with the arrow keys; Backspace / Delete removes the chip.
+ *
+ * @group Components
+ */
+declare class RdxComboboxChip {
+    private readonly element;
+    private readonly chips;
+    private readonly rootContext;
+    /** The value this chip represents. */
+    readonly value: _angular_core.InputSignal<AcceptableValue>;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxChip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxChip, "[rdxComboboxChip]", ["rdxComboboxChip"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Removes its chip's value from the selection, keeping focus in the input.
+ *
+ * @group Components
+ */
+declare class RdxComboboxChipRemove {
+    private readonly rootContext;
+    private readonly chipContext;
+    onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxComboboxChipRemove, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxComboboxChipRemove, "button[rdxComboboxChipRemove]", ["rdxComboboxChipRemove"], {}, {}, never, never, true, never>;
+}
+
+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 ɵ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 };