@angular/aria 21.1.0-next.0 → 21.1.0-next.2

package/types/_list-navigation-chunk.d.ts

@@ -0,0 +1,212 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Options that are applicable to all event handlers.
+ *
+ * This library has not yet had a need for stopPropagationImmediate.
+ */
+interface EventHandlerOptions {
+    stopPropagation: boolean;
+    preventDefault: boolean;
+}
+/** A basic event handler. */
+type EventHandler<T extends Event> = (event: T) => void;
+/** A function that determines whether an event is to be handled. */
+type EventMatcher<T extends Event> = (event: T) => boolean;
+/** A config that specifies how to handle a particular event. */
+interface EventHandlerConfig<T extends Event> extends EventHandlerOptions {
+    matcher: EventMatcher<T>;
+    handler: EventHandler<T>;
+}
+/** Bit flag representation of the possible modifier keys that can be present on an event. */
+declare enum Modifier {
+    None = 0,
+    Ctrl = 1,
+    Shift = 2,
+    Alt = 4,
+    Meta = 8,
+    Any = "Any"
+}
+type ModifierInputs = Modifier | Modifier[];
+/**
+ * Abstract base class for all event managers.
+ *
+ * Event managers are designed to normalize how event handlers are authored and create a safety net
+ * for common event handling gotchas like remembering to call preventDefault or stopPropagation.
+ */
+declare abstract class EventManager<T extends Event> {
+    protected configs: EventHandlerConfig<T>[];
+    abstract options: EventHandlerOptions;
+    /** Runs the handlers that match with the given event. */
+    handle(event: T): void;
+    /** Configures the event manager to handle specific events. (See subclasses for more). */
+    abstract on(...args: [...unknown[]]): this;
+}
+
+type SignalLike<T> = () => T;
+interface WritableSignalLike<T> extends SignalLike<T> {
+    set(value: T): void;
+    update(updateFn: (value: T) => T): void;
+}
+/** Converts a getter setter style signal to a WritableSignalLike. */
+declare function convertGetterSetterToWritableSignalLike<T>(getter: () => T, setter: (v: T) => void): WritableSignalLike<T>;
+
+/**
+ * Used to represent a keycode.
+ *
+ * This is used to match whether an events keycode should be handled. The ability to match using a
+ * string, SignalLike, or Regexp gives us more flexibility when authoring event handlers.
+ */
+type KeyCode = string | SignalLike<string> | RegExp;
+/**
+ * An event manager that is specialized for handling keyboard events. By default this manager stops
+ * propagation and prevents default on all events it handles.
+ */
+declare class KeyboardEventManager<T extends KeyboardEvent> extends EventManager<T> {
+    options: EventHandlerOptions;
+    /** Configures this event manager to handle events with a specific key and no modifiers. */
+    on(key: KeyCode, handler: EventHandler<T>, options?: Partial<EventHandlerOptions>): this;
+    /**  Configures this event manager to handle events with a specific modifer and key combination. */
+    on(modifiers: ModifierInputs, key: KeyCode, handler: EventHandler<T>, options?: Partial<EventHandlerOptions>): this;
+    private _normalizeInputs;
+    private _isMatch;
+}
+
+/**
+ * The different mouse buttons that may appear on a pointer event.
+ */
+declare enum MouseButton {
+    Main = 0,
+    Auxiliary = 1,
+    Secondary = 2
+}
+/** An event manager that is specialized for handling pointer events. */
+declare class PointerEventManager<T extends PointerEvent> extends EventManager<T> {
+    options: EventHandlerOptions;
+    /**
+     * Configures this event manager to handle events with a specific modifer and mouse button
+     * combination.
+     */
+    on(button: MouseButton, modifiers: ModifierInputs, handler: EventHandler<T>): this;
+    /**
+     * Configures this event manager to handle events with a specific mouse button and no modifiers.
+     */
+    on(modifiers: ModifierInputs, handler: EventHandler<T>): this;
+    /**
+     * Configures this event manager to handle events with the main mouse button and no modifiers.
+     *
+     * @param handler The handler function
+     * @param options Options for whether to stop propagation or prevent default.
+     */
+    on(handler: EventHandler<T>): this;
+    private _normalizeInputs;
+    _isMatch(event: PointerEvent, button: MouseButton, modifiers: ModifierInputs): boolean;
+}
+
+/** Represents an item in a collection, such as a listbox option, than may receive focus. */
+interface ListFocusItem {
+    /** A unique identifier for the item. */
+    id: SignalLike<string>;
+    /** The html element that should receive focus. */
+    element: SignalLike<HTMLElement | undefined>;
+    /** Whether an item is disabled. */
+    disabled: SignalLike<boolean>;
+    /** The index of the item in the list. */
+    index: SignalLike<number>;
+}
+/** Represents the required inputs for a collection that contains focusable items. */
+interface ListFocusInputs<T extends ListFocusItem> {
+    /** The focus strategy used by the list. */
+    focusMode: SignalLike<'roving' | 'activedescendant'>;
+    /** Whether the list is disabled. */
+    disabled: SignalLike<boolean>;
+    /** The items in the list. */
+    items: SignalLike<T[]>;
+    /** The active item. */
+    activeItem: WritableSignalLike<T | undefined>;
+    /** Whether disabled items in the list should be focusable. */
+    softDisabled: SignalLike<boolean>;
+    element: SignalLike<HTMLElement | undefined>;
+}
+/** Controls focus for a list of items. */
+declare class ListFocus<T extends ListFocusItem> {
+    readonly inputs: ListFocusInputs<T>;
+    /** The last item that was active. */
+    prevActiveItem: _angular_core.WritableSignal<T | undefined>;
+    /** The index of the last item that was active. */
+    prevActiveIndex: _angular_core.Signal<number>;
+    /** The current active index in the list. */
+    activeIndex: _angular_core.Signal<number>;
+    constructor(inputs: ListFocusInputs<T>);
+    /** Whether the list is in a disabled state. */
+    isListDisabled(): boolean;
+    /** The id of the current active item. */
+    getActiveDescendant(): string | undefined;
+    /** The tab index for the list. */
+    getListTabIndex(): -1 | 0;
+    /** Returns the tab index for the given item. */
+    getItemTabIndex(item: T): -1 | 0;
+    /** Moves focus to the given item if it is focusable. */
+    focus(item: T, opts?: {
+        focusElement?: boolean;
+    }): boolean;
+    /** Returns true if the given item can be navigated to. */
+    isFocusable(item: T): boolean;
+}
+
+/** Represents an item in a collection, such as a listbox option, than can be navigated to. */
+interface ListNavigationItem extends ListFocusItem {
+}
+/** Represents the required inputs for a collection that has navigable items. */
+interface ListNavigationInputs<T extends ListNavigationItem> extends ListFocusInputs<T> {
+    /** Whether focus should wrap when navigating. */
+    wrap: SignalLike<boolean>;
+    /** Whether the list is vertically or horizontally oriented. */
+    orientation: SignalLike<'vertical' | 'horizontal'>;
+    /** The direction that text is read based on the users locale. */
+    textDirection: SignalLike<'rtl' | 'ltr'>;
+}
+/** Controls navigation for a list of items. */
+declare class ListNavigation<T extends ListNavigationItem> {
+    readonly inputs: ListNavigationInputs<T> & {
+        focusManager: ListFocus<T>;
+    };
+    constructor(inputs: ListNavigationInputs<T> & {
+        focusManager: ListFocus<T>;
+    });
+    /** Navigates to the given item. */
+    goto(item?: T, opts?: {
+        focusElement?: boolean;
+    }): boolean;
+    /** Navigates to the next item in the list. */
+    next(opts?: {
+        focusElement?: boolean;
+    }): boolean;
+    /** Peeks the next item in the list. */
+    peekNext(): T | undefined;
+    /** Navigates to the previous item in the list. */
+    prev(opts?: {
+        focusElement?: boolean;
+    }): boolean;
+    /** Peeks the previous item in the list. */
+    peekPrev(): T | undefined;
+    /** Navigates to the first item in the list. */
+    first(opts?: {
+        focusElement?: boolean;
+    }): boolean;
+    /** Navigates to the last item in the list. */
+    last(opts?: {
+        focusElement?: boolean;
+    }): boolean;
+    /** Gets the first focusable item from the given list of items. */
+    peekFirst(items?: T[]): T | undefined;
+    /** Gets the last focusable item from the given list of items. */
+    peekLast(items?: T[]): T | undefined;
+    /** Advances to the next or previous focusable item in the list based on the given delta. */
+    private _advance;
+    /** Peeks the next or previous focusable item in the list based on the given delta. */
+    private _peek;
+}
+
+export { KeyboardEventManager, ListFocus, ListNavigation, PointerEventManager, convertGetterSetterToWritableSignalLike };
+export type { ListFocusInputs, ListFocusItem, ListNavigationInputs, ListNavigationItem, SignalLike, WritableSignalLike };

package/types/_listbox-chunk.d.ts

@@ -0,0 +1,106 @@
+import * as _angular_core from '@angular/core';
+import { SignalLike, KeyboardEventManager, PointerEventManager } from './_list-navigation-chunk.js';
+import { ListItem, ListInputs, List } from './_list-chunk.js';
+
+/**
+ * Represents the properties exposed by a listbox that need to be accessed by an option.
+ * This exists to avoid circular dependency errors between the listbox and option.
+ */
+interface ListboxPattern$1<V> {
+    inputs: ListInputs<OptionPattern<V>, V>;
+    listBehavior: List<OptionPattern<V>, V>;
+}
+/** Represents the required inputs for an option in a listbox. */
+interface OptionInputs<V> extends Omit<ListItem<V>, 'index' | 'selectable'> {
+    listbox: SignalLike<ListboxPattern$1<V> | undefined>;
+}
+/** Represents an option in a listbox. */
+declare class OptionPattern<V> {
+    /** A unique identifier for the option. */
+    id: SignalLike<string>;
+    /** The value of the option. */
+    value: SignalLike<V>;
+    /** The position of the option in the list. */
+    index: _angular_core.Signal<number>;
+    /** Whether the option is active. */
+    active: _angular_core.Signal<boolean>;
+    /** Whether the option is selected. */
+    selected: _angular_core.Signal<boolean | undefined>;
+    /** Whether the option is selectable. */
+    selectable: () => boolean;
+    /** Whether the option is disabled. */
+    disabled: SignalLike<boolean>;
+    /** The text used by the typeahead search. */
+    searchTerm: SignalLike<string>;
+    /** A reference to the parent listbox. */
+    listbox: SignalLike<ListboxPattern$1<V> | undefined>;
+    /** The tab index of the option. */
+    tabIndex: _angular_core.Signal<0 | -1 | undefined>;
+    /** The html element that should receive focus. */
+    element: SignalLike<HTMLElement | undefined>;
+    constructor(args: OptionInputs<V>);
+}
+
+/** Represents the required inputs for a listbox. */
+type ListboxInputs<V> = ListInputs<OptionPattern<V>, V> & {
+    /** A unique identifier for the listbox. */
+    id: SignalLike<string>;
+    /** Whether the listbox is readonly. */
+    readonly: SignalLike<boolean>;
+};
+/** Controls the state of a listbox. */
+declare class ListboxPattern<V> {
+    readonly inputs: ListboxInputs<V>;
+    listBehavior: List<OptionPattern<V>, V>;
+    /** Whether the list is vertically or horizontally oriented. */
+    orientation: SignalLike<'vertical' | 'horizontal'>;
+    /** Whether the listbox is disabled. */
+    disabled: _angular_core.Signal<boolean>;
+    /** Whether the listbox is readonly. */
+    readonly: SignalLike<boolean>;
+    /** The tab index of the listbox. */
+    tabIndex: SignalLike<-1 | 0>;
+    /** The id of the current active item. */
+    activeDescendant: _angular_core.Signal<string | undefined>;
+    /** Whether multiple items in the list can be selected at once. */
+    multi: SignalLike<boolean>;
+    /** The number of items in the listbox. */
+    setsize: _angular_core.Signal<number>;
+    /** Whether the listbox selection follows focus. */
+    followFocus: _angular_core.Signal<boolean>;
+    /** Whether the listbox should wrap. Used to disable wrapping while range selecting. */
+    wrap: _angular_core.WritableSignal<boolean>;
+    /** The key used to navigate to the previous item in the list. */
+    prevKey: _angular_core.Signal<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
+    /** The key used to navigate to the next item in the list. */
+    nextKey: _angular_core.Signal<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
+    /** Represents the space key. Does nothing when the user is actively using typeahead. */
+    dynamicSpaceKey: _angular_core.Signal<"" | " ">;
+    /** The regexp used to decide if a key should trigger typeahead. */
+    typeaheadRegexp: RegExp;
+    /** The keydown event manager for the listbox. */
+    keydown: _angular_core.Signal<KeyboardEventManager<KeyboardEvent>>;
+    /** The pointerdown event manager for the listbox. */
+    pointerdown: _angular_core.Signal<PointerEventManager<PointerEvent>>;
+    constructor(inputs: ListboxInputs<V>);
+    /** Returns a set of violations */
+    validate(): string[];
+    /** Handles keydown events for the listbox. */
+    onKeydown(event: KeyboardEvent): void;
+    onPointerdown(event: PointerEvent): void;
+    /**
+     * Sets the listbox to it's default initial state.
+     *
+     * Sets the active index of the listbox to the first focusable selected
+     * item if one exists. Otherwise, sets focus to the first focusable item.
+     *
+     * This method should be called once the listbox and it's options are properly initialized,
+     * meaning the ListboxPattern and OptionPatterns should have references to each other before this
+     * is called.
+     */
+    setDefaultState(): void;
+    protected _getItem(e: PointerEvent): OptionPattern<V> | undefined;
+}
+
+export { ListboxPattern, OptionPattern };
+export type { ListboxInputs, OptionInputs };

package/types/accordion.d.ts

@@ -1,8 +1,8 @@
-import * as _angular_cdk_bidi from '@angular/cdk/bidi';
 import * as _angular_core from '@angular/core';
 import { WritableSignal } from '@angular/core';
 import * as i1 from '@angular/aria/private';
 import { AccordionTriggerPattern, AccordionPanelPattern, AccordionGroupPattern } from '@angular/aria/private';
+import * as _angular_cdk_bidi from '@angular/cdk/bidi';
 
 /**
  * The content panel of an accordion item that is conditionally visible.
@@ -47,53 +47,7 @@ declare class AccordionPanel {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionPanel, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionPanel, "[ngAccordionPanel]", ["ngAccordionPanel"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "panelId": { "alias": "panelId"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.DeferredContentAware; inputs: { "preserveContent": "preserveContent"; }; outputs: {}; }]>;
 }
-/**
- * The trigger that toggles the visibility of its associated `ngAccordionPanel`.
- *
- * This directive requires a `panelId` that must match the `panelId` of the `ngAccordionPanel` it
- * controls. When clicked, it will expand or collapse the panel. It also handles keyboard
- * interactions for navigation within the `ngAccordionGroup`. It applies `role="button"` and manages
- * `aria-expanded`, `aria-controls`, and `aria-disabled` attributes for accessibility.
- * The `disabled` input can be used to disable the trigger.
- *
- * ```html
- * <button ngAccordionTrigger panelId="unique-id-1">
- *   Accordion Trigger Text
- * </button>
- * ```
- *
- * @developerPreview 21.0
- */
-declare class AccordionTrigger {
-    /** A reference to the trigger element. */
-    private readonly _elementRef;
-    /** A reference to the trigger element. */
-    readonly element: HTMLElement;
-    /** The parent AccordionGroup. */
-    private readonly _accordionGroup;
-    /** A unique identifier for the widget. */
-    readonly id: _angular_core.InputSignal<string>;
-    /** A local unique identifier for the trigger, used to match with its panel's `panelId`. */
-    readonly panelId: _angular_core.InputSignal<string>;
-    /** Whether the trigger is disabled. */
-    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Whether the corresponding panel is expanded. */
-    readonly expanded: _angular_core.ModelSignal<boolean>;
-    /** Whether the trigger is active. */
-    readonly active: _angular_core.Signal<boolean>;
-    /** The accordion panel pattern controlled by this trigger. This is set by AccordionGroup. */
-    readonly _accordionPanelPattern: WritableSignal<AccordionPanelPattern | undefined>;
-    /** The UI pattern instance for this trigger. */
-    readonly _pattern: AccordionTriggerPattern;
-    /** Expands this item. */
-    expand(): void;
-    /** Collapses this item. */
-    collapse(): void;
-    /** Toggles the expansion state of this item. */
-    toggle(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionTrigger, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionTrigger, "[ngAccordionTrigger]", ["ngAccordionTrigger"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "panelId": { "alias": "panelId"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, never, never, true, never>;
-}
+
 /**
  * A container for a group of accordion items. It manages the overall state and
  * interactions of the accordion, such as keyboard navigation and expansion mode.
@@ -141,7 +95,7 @@ declare class AccordionGroup {
     /** The AccordionPanels nested inside this group. */
     private readonly _panels;
     /** The text direction (ltr or rtl). */
-    readonly textDirection: WritableSignal<_angular_cdk_bidi.Direction>;
+    readonly textDirection: _angular_core.WritableSignal<_angular_cdk_bidi.Direction>;
     /** Whether the entire accordion group is disabled. */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether multiple accordion items can be expanded simultaneously. */
@@ -165,6 +119,55 @@ declare class AccordionGroup {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionGroup, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionGroup, "[ngAccordionGroup]", ["ngAccordionGroup"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "multiExpandable": { "alias": "multiExpandable"; "required": false; "isSignal": true; }; "softDisabled": { "alias": "softDisabled"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, {}, ["_triggers", "_panels"], never, true, never>;
 }
+
+/**
+ * The trigger that toggles the visibility of its associated `ngAccordionPanel`.
+ *
+ * This directive requires a `panelId` that must match the `panelId` of the `ngAccordionPanel` it
+ * controls. When clicked, it will expand or collapse the panel. It also handles keyboard
+ * interactions for navigation within the `ngAccordionGroup`. It applies `role="button"` and manages
+ * `aria-expanded`, `aria-controls`, and `aria-disabled` attributes for accessibility.
+ * The `disabled` input can be used to disable the trigger.
+ *
+ * ```html
+ * <button ngAccordionTrigger panelId="unique-id-1">
+ *   Accordion Trigger Text
+ * </button>
+ * ```
+ *
+ * @developerPreview 21.0
+ */
+declare class AccordionTrigger {
+    /** A reference to the trigger element. */
+    private readonly _elementRef;
+    /** A reference to the trigger element. */
+    readonly element: HTMLElement;
+    /** The parent AccordionGroup. */
+    private readonly _accordionGroup;
+    /** A unique identifier for the widget. */
+    readonly id: _angular_core.InputSignal<string>;
+    /** A local unique identifier for the trigger, used to match with its panel's `panelId`. */
+    readonly panelId: _angular_core.InputSignal<string>;
+    /** Whether the trigger is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the corresponding panel is expanded. */
+    readonly expanded: _angular_core.ModelSignal<boolean>;
+    /** Whether the trigger is active. */
+    readonly active: _angular_core.Signal<boolean>;
+    /** The accordion panel pattern controlled by this trigger. This is set by AccordionGroup. */
+    readonly _accordionPanelPattern: WritableSignal<AccordionPanelPattern | undefined>;
+    /** The UI pattern instance for this trigger. */
+    readonly _pattern: AccordionTriggerPattern;
+    /** Expands this item. */
+    expand(): void;
+    /** Collapses this item. */
+    collapse(): void;
+    /** Toggles the expansion state of this item. */
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionTrigger, "[ngAccordionTrigger]", ["ngAccordionTrigger"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "panelId": { "alias": "panelId"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, never, never, true, never>;
+}
+
 /**
  * A structural directive that provides a mechanism for lazily rendering the content for an
  * `ngAccordionPanel`.

package/types/combobox.d.ts

@@ -1,81 +1,42 @@
+import { Combobox, ComboboxPopup } from './_combobox-chunk.js';
+import { ComboboxDialogPattern } from './_combobox-chunk.d2.ts';
 import * as _angular_core from '@angular/core';
-import { WritableSignal } from '@angular/core';
-import * as _angular_cdk_bidi from '@angular/cdk/bidi';
 import * as i1 from '@angular/aria/private';
-import { ComboboxPattern, ComboboxDialogPattern, ComboboxListboxControls, ComboboxTreeControls } from '@angular/aria/private';
+import '@angular/cdk/bidi';
+import './_list-navigation-chunk.js';
+import './_list-chunk.js';
 
 /**
- * The container element that wraps a combobox input and popup, and orchestrates its behavior.
- *
- * The `ngCombobox` directive is the main entry point for creating a combobox and customizing its
- * behavior. It coordinates the interactions between the `ngComboboxInput` and the popup, which
- * is defined by a `ng-template` with the `ngComboboxPopupContainer` directive. If using the
- * `CdkOverlay`, the `cdkConnectedOverlay` directive takes the place of `ngComboboxPopupContainer`.
+ * Integrates a native `<dialog>` element with the combobox, allowing for
+ * a modal or non-modal popup experience. It handles the opening and closing of the dialog
+ * based on the combobox's expanded state.
  *
  * ```html
- * <div ngCombobox filterMode="highlight">
- *   <input
- *     ngComboboxInput
- *     placeholder="Search for a state..."
- *     [(value)]="searchString"
- *   />
- *
- *   <ng-template ngComboboxPopupContainer>
- *     <div ngListbox [(value)]="selectedValue">
- *       @for (option of filteredOptions(); track option) {
- *         <div ngOption [value]="option" [label]="option">
- *           <span>{{option}}</span>
- *         </div>
- *       }
- *     </div>
- *   </ng-template>
- * </div>
+ * <ng-template ngComboboxPopupContainer>
+ *   <dialog ngComboboxDialog class="example-dialog">
+ *     <!-- ... dialog content ... -->
+ *   </dialog>
+ * </ng-template>
  * ```
  *
  * @developerPreview 21.0
  */
-declare class Combobox<V> {
-    /** The directionality (LTR / RTL) context for the application (or a subtree of it). */
-    private readonly _directionality;
-    /** A signal wrapper for directionality. */
-    protected textDirection: _angular_core.Signal<_angular_cdk_bidi.Direction>;
-    /** The element that the combobox is attached to. */
+declare class ComboboxDialog {
+    /** The dialog element. */
     private readonly _elementRef;
-    /** A reference to the combobox element. */
+    /** A reference to the dialog element. */
     readonly element: HTMLElement;
-    /** The DeferredContentAware host directive. */
-    private readonly _deferredContentAware;
-    /** The combobox popup. */
-    readonly popup: _angular_core.Signal<ComboboxPopup<V> | undefined>;
-    /**
-     * The filter mode for the combobox.
-     * - `manual`: The consumer is responsible for filtering the options.
-     * - `auto-select`: The combobox automatically selects the first matching option.
-     * - `highlight`: The combobox highlights matching text in the options without changing selection.
-     */
-    filterMode: _angular_core.InputSignal<"manual" | "auto-select" | "highlight">;
-    /** 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>;
-    /** The value of the first matching item in the popup. */
-    readonly firstMatch: _angular_core.InputSignal<V | undefined>;
-    /** Whether the combobox is expanded. */
-    readonly expanded: _angular_core.Signal<boolean>;
-    /** Whether the combobox popup should always be expanded, regardless of user interaction. */
-    readonly alwaysExpanded: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Input element connected to the combobox, if any. */
-    readonly inputElement: _angular_core.Signal<HTMLInputElement | undefined>;
-    /** The combobox ui pattern. */
-    readonly _pattern: ComboboxPattern<any, V>;
+    /** The combobox that the dialog belongs to. */
+    readonly combobox: Combobox<any>;
+    /** A reference to the parent combobox popup, if one exists. */
+    private readonly _popup;
+    _pattern: ComboboxDialogPattern;
     constructor();
-    /** Opens the combobox to the selected item. */
-    open(): void;
-    /** Closes the combobox. */
     close(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Combobox<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Combobox<any>, "[ngCombobox]", ["ngCombobox"], { "filterMode": { "alias": "filterMode"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "firstMatch": { "alias": "firstMatch"; "required": false; "isSignal": true; }; "alwaysExpanded": { "alias": "alwaysExpanded"; "required": false; "isSignal": true; }; }, {}, ["popup"], never, true, [{ directive: typeof i1.DeferredContentAware; inputs: { "preserveContent": "preserveContent"; }; outputs: {}; }]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComboboxDialog, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ComboboxDialog, "dialog[ngComboboxDialog]", ["ngComboboxDialog"], {}, {}, never, never, true, [{ directive: typeof ComboboxPopup; inputs: {}; outputs: {}; }]>;
 }
+
 /**
  * An input that is part of a combobox. It is responsible for displaying the
  * current value and handling user input for filtering and selection.
@@ -107,6 +68,7 @@ declare class ComboboxInput {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComboboxInput, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ComboboxInput, "input[ngComboboxInput]", ["ngComboboxInput"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
 }
+
 /**
  * A structural directive that marks the `ng-template` to be used as the popup
  * for a combobox. This content is conditionally rendered.
@@ -141,53 +103,5 @@ declare class ComboboxPopupContainer {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComboboxPopupContainer, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ComboboxPopupContainer, "ng-template[ngComboboxPopupContainer]", ["ngComboboxPopupContainer"], {}, {}, never, never, true, [{ directive: typeof i1.DeferredContent; inputs: {}; outputs: {}; }]>;
 }
-/**
- * Identifies an element as a popup for an `ngCombobox`.
- *
- * This directive acts as a bridge, allowing the `ngCombobox` to discover and interact
- * with the underlying control (e.g., `ngListbox`, `ngTree`, or `ngComboboxDialog`) that
- * manages the options. It's primarily used as a host directive and is responsible for
- * exposing the popup's control pattern to the parent combobox.
- *
- * @developerPreview 21.0
- */
-declare class ComboboxPopup<V> {
-    /** The combobox that the popup belongs to. */
-    readonly combobox: Combobox<V> | null;
-    /** The popup controls exposed to the combobox. */
-    readonly _controls: WritableSignal<ComboboxDialogPattern | ComboboxListboxControls<any, V> | ComboboxTreeControls<any, V> | undefined>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComboboxPopup<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ComboboxPopup<any>, "[ngComboboxPopup]", ["ngComboboxPopup"], {}, {}, never, never, true, never>;
-}
-/**
- * Integrates a native `<dialog>` element with the combobox, allowing for
- * a modal or non-modal popup experience. It handles the opening and closing of the dialog
- * based on the combobox's expanded state.
- *
- * ```html
- * <ng-template ngComboboxPopupContainer>
- *   <dialog ngComboboxDialog class="example-dialog">
- *     <!-- ... dialog content ... -->
- *   </dialog>
- * </ng-template>
- * ```
- *
- * @developerPreview 21.0
- */
-declare class ComboboxDialog {
-    /** The dialog element. */
-    private readonly _elementRef;
-    /** A reference to the dialog element. */
-    readonly element: HTMLElement;
-    /** The combobox that the dialog belongs to. */
-    readonly combobox: Combobox<any>;
-    /** A reference to the parent combobox popup, if one exists. */
-    private readonly _popup;
-    _pattern: ComboboxDialogPattern;
-    constructor();
-    close(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComboboxDialog, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ComboboxDialog, "dialog[ngComboboxDialog]", ["ngComboboxDialog"], {}, {}, never, never, true, [{ directive: typeof ComboboxPopup; inputs: {}; outputs: {}; }]>;
-}
 
 export { Combobox, ComboboxDialog, ComboboxInput, ComboboxPopup, ComboboxPopupContainer };