@angular/cdk-experimental 21.0.0-next.4 → 21.0.0-next.6

package/{listbox.d.d.ts → types/_listbox-chunk.d.ts}

@@ -1,6 +1,7 @@
 import * as _angular_core from '@angular/core';
-import { SignalLike, KeyboardEventManager, PointerEventManager } from './pointer-event-manager.d.js';
-import { ListItem, ListInputs, List } from './list.d.js';
+import { SignalLike } from './_list-navigation-chunk.js';
+import { ListItem, ListInputs, List } from './_list-chunk.js';
+import { KeyboardEventManager, PointerEventManager } from './_pointer-event-manager-chunk.js';
 
 /**
  * Represents the properties exposed by a listbox that need to be accessed by an option.
@@ -41,6 +42,9 @@ declare class OptionPattern<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. */
@@ -54,7 +58,7 @@ declare class ListboxPattern<V> {
     /** Whether the listbox is readonly. */
     readonly: SignalLike<boolean>;
     /** The tabindex of the listbox. */
-    tabindex: _angular_core.Signal<0 | -1>;
+    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. */
@@ -94,7 +98,7 @@ declare class ListboxPattern<V> {
      * is called.
      */
     setDefaultState(): void;
-    private _getItem;
+    protected _getItem(e: PointerEvent): OptionPattern<V> | undefined;
 }
 
 export { ListboxPattern, OptionPattern };

package/types/_pointer-event-manager-chunk.d.ts

@@ -0,0 +1,98 @@
+import { SignalLike } from './_list-navigation-chunk.js';
+
+/**
+ * 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;
+}
+
+/**
+ * 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>): this;
+    /**  Configures this event manager to handle events with a specific modifer and key combination. */
+    on(modifiers: ModifierInputs, key: KeyCode, handler: EventHandler<T>): 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;
+}
+
+export { KeyboardEventManager, PointerEventManager };

package/types/_radio-group-chunk.d.ts

@@ -0,0 +1,92 @@
+import * as _angular_core from '@angular/core';
+import { KeyboardEventManager, PointerEventManager } from './_pointer-event-manager-chunk.js';
+import { ListItem, ListInputs, List } from './_list-chunk.js';
+import { SignalLike } from './_list-navigation-chunk.js';
+
+/** Represents the required inputs for a radio button in a radio group. */
+interface RadioButtonInputs<V> extends Omit<ListItem<V>, 'searchTerm' | 'index'> {
+    /** A reference to the parent radio group. */
+    group: SignalLike<RadioGroupPattern<V> | undefined>;
+}
+/** Represents a radio button within a radio group. */
+declare class RadioButtonPattern<V> {
+    readonly inputs: RadioButtonInputs<V>;
+    /** A unique identifier for the radio button. */
+    readonly id: SignalLike<string>;
+    /** The value associated with the radio button. */
+    readonly value: SignalLike<V>;
+    /** The position of the radio button within the group. */
+    readonly index: SignalLike<number>;
+    /** Whether the radio button is currently the active one (focused). */
+    readonly active: _angular_core.Signal<boolean>;
+    /** Whether the radio button is selected. */
+    readonly selected: SignalLike<boolean>;
+    /** Whether the radio button is disabled. */
+    readonly disabled: SignalLike<boolean>;
+    /** A reference to the parent radio group. */
+    readonly group: SignalLike<RadioGroupPattern<V> | undefined>;
+    /** The tabindex of the radio button. */
+    readonly tabindex: _angular_core.Signal<0 | -1 | undefined>;
+    /** The HTML element associated with the radio button. */
+    readonly element: SignalLike<HTMLElement>;
+    /** The search term for typeahead. */
+    readonly searchTerm: () => string;
+    constructor(inputs: RadioButtonInputs<V>);
+}
+
+/** Represents the required inputs for a radio group. */
+type RadioGroupInputs<V> = Omit<ListInputs<RadioButtonPattern<V>, V>, 'multi' | 'selectionMode' | 'wrap' | 'typeaheadDelay'> & {
+    /** Whether the radio group is disabled. */
+    disabled: SignalLike<boolean>;
+    /** Whether the radio group is readonly. */
+    readonly: SignalLike<boolean>;
+    /** A function that returns the radio button associated with a given element. */
+    getItem: (e: PointerEvent) => RadioButtonPattern<V> | undefined;
+};
+/** Controls the state of a radio group. */
+declare class RadioGroupPattern<V> {
+    readonly inputs: RadioGroupInputs<V>;
+    /** The list behavior for the radio group. */
+    readonly listBehavior: List<RadioButtonPattern<V>, V>;
+    /** Whether the radio group is vertically or horizontally oriented. */
+    readonly orientation: SignalLike<'vertical' | 'horizontal'>;
+    /** Whether focus should wrap when navigating. */
+    readonly wrap: _angular_core.WritableSignal<boolean>;
+    /** The selection strategy used by the radio group. */
+    readonly selectionMode: _angular_core.WritableSignal<"follow" | "explicit">;
+    /** Whether the radio group is disabled. */
+    readonly disabled: _angular_core.Signal<boolean>;
+    /** The currently selected radio button. */
+    readonly selectedItem: _angular_core.Signal<RadioButtonPattern<V>>;
+    /** Whether the radio group is readonly. */
+    readonly readonly: _angular_core.Signal<boolean>;
+    /** The tabindex of the radio group. */
+    readonly tabindex: _angular_core.Signal<0 | -1>;
+    /** The id of the current active radio button (if using activedescendant). */
+    readonly activedescendant: _angular_core.Signal<string | undefined>;
+    /** The key used to navigate to the previous radio button. */
+    private readonly _prevKey;
+    /** The key used to navigate to the next radio button. */
+    private readonly _nextKey;
+    /** The keydown event manager for the radio group. */
+    readonly keydown: _angular_core.Signal<KeyboardEventManager<KeyboardEvent>>;
+    /** The pointerdown event manager for the radio group. */
+    readonly pointerdown: _angular_core.Signal<PointerEventManager<PointerEvent>>;
+    constructor(inputs: RadioGroupInputs<V>);
+    /** Handles keydown events for the radio group. */
+    onKeydown(event: KeyboardEvent): void;
+    /** Handles pointerdown events for the radio group. */
+    onPointerdown(event: PointerEvent): void;
+    /**
+     * Sets the radio group to its default initial state.
+     *
+     * Sets the active index to the selected radio button if one exists and is focusable.
+     * Otherwise, sets the active index to the first focusable radio button.
+     */
+    setDefaultState(): void;
+    /** Validates the state of the radio group and returns a list of accessibility violations. */
+    validate(): string[];
+}
+
+export { RadioButtonPattern, RadioGroupPattern };
+export type { RadioButtonInputs, RadioGroupInputs };

package/{tabs.d.d.ts → types/_tabs-chunk.d.ts}

@@ -1,7 +1,8 @@
 import * as _angular_core from '@angular/core';
-import { SignalLike, KeyboardEventManager, PointerEventManager } from './pointer-event-manager.d.js';
-import { ExpansionItem, ExpansionControl, ListExpansionInputs, ListExpansion } from './expansion.d.js';
-import { ListItem, ListInputs, List } from './list.d.js';
+import { KeyboardEventManager, PointerEventManager } from './_pointer-event-manager-chunk.js';
+import { ExpansionItem, ExpansionControl, ListExpansionInputs, ListExpansion } from './_expansion-chunk.js';
+import { SignalLike } from './_list-navigation-chunk.js';
+import { ListItem, ListInputs, List } from './_list-chunk.js';
 
 /** Represents the required inputs for the label control. */
 interface LabelControlInputs {

package/types/_toolbar-chunk.d.ts

@@ -0,0 +1,150 @@
+import * as _angular_core from '@angular/core';
+import { SignalLike } from './_list-navigation-chunk.js';
+import { ListItem, ListInputs, List } from './_list-chunk.js';
+
+/** Represents the required inputs for a toolbar widget in a toolbar. */
+interface ToolbarWidgetInputs<V> extends Omit<ListItem<V>, 'searchTerm' | 'value' | 'index'> {
+    /** A reference to the parent toolbar. */
+    toolbar: SignalLike<ToolbarPattern<V>>;
+}
+declare class ToolbarWidgetPattern<V> implements ListItem<V> {
+    readonly inputs: ToolbarWidgetInputs<V>;
+    /** A unique identifier for the widget. */
+    readonly id: SignalLike<string>;
+    /** The html element that should receive focus. */
+    readonly element: SignalLike<HTMLElement>;
+    /** Whether the widget is disabled. */
+    readonly disabled: SignalLike<boolean>;
+    /** A reference to the parent toolbar. */
+    readonly toolbar: SignalLike<ToolbarPattern<V>>;
+    /** The tabindex of the widgdet. */
+    readonly tabindex: _angular_core.Signal<0 | -1>;
+    /** The text used by the typeahead search. */
+    readonly searchTerm: () => string;
+    /** The value associated with the widget. */
+    readonly value: () => V;
+    /** The position of the widget within the toolbar. */
+    readonly index: _angular_core.Signal<number>;
+    /** Whether the widget is currently the active one (focused). */
+    readonly active: _angular_core.Signal<boolean>;
+    constructor(inputs: ToolbarWidgetInputs<V>);
+}
+
+/** An interface that allows sub patterns to expose the necessary controls for the toolbar. */
+interface ToolbarWidgetGroupControls {
+    /** Whether the widget group is currently on the first item. */
+    isOnFirstItem(): boolean;
+    /** Whether the widget group is currently on the last item. */
+    isOnLastItem(): boolean;
+    /** Navigates to the next widget in the group. */
+    next(wrap: boolean): void;
+    /** Navigates to the previous widget in the group. */
+    prev(wrap: boolean): void;
+    /** Navigates to the first widget in the group. */
+    first(): void;
+    /** Navigates to the last widget in the group. */
+    last(): void;
+    /** Removes focus from the widget group. */
+    unfocus(): void;
+    /** Triggers the action of the currently active widget in the group. */
+    trigger(): void;
+    /** Navigates to the widget targeted by a pointer event. */
+    goto(event: PointerEvent): void;
+    /** Sets the widget group to its default initial state. */
+    setDefaultState(): void;
+}
+/** Represents the required inputs for a toolbar widget group. */
+interface ToolbarWidgetGroupInputs<V> extends Omit<ListItem<V>, 'searchTerm' | 'value' | 'index'> {
+    /** A reference to the parent toolbar. */
+    toolbar: SignalLike<ToolbarPattern<V> | undefined>;
+    /** The controls for the sub patterns associated with the toolbar. */
+    controls: SignalLike<ToolbarWidgetGroupControls | undefined>;
+}
+/** A group of widgets within a toolbar that provides nested navigation. */
+declare class ToolbarWidgetGroupPattern<V> implements ListItem<V> {
+    readonly inputs: ToolbarWidgetGroupInputs<V>;
+    /** A unique identifier for the widget. */
+    readonly id: SignalLike<string>;
+    /** The html element that should receive focus. */
+    readonly element: SignalLike<HTMLElement>;
+    /** Whether the widget is disabled. */
+    readonly disabled: SignalLike<boolean>;
+    /** A reference to the parent toolbar. */
+    readonly toolbar: SignalLike<ToolbarPattern<V> | undefined>;
+    /** The text used by the typeahead search. */
+    readonly searchTerm: () => string;
+    /** The value associated with the widget. */
+    readonly value: () => V;
+    /** The position of the widget within the toolbar. */
+    readonly index: _angular_core.Signal<number>;
+    /** The actions that can be performed on the widget group. */
+    readonly controls: SignalLike<ToolbarWidgetGroupControls>;
+    /** Default toolbar widget group controls when no controls provided. */
+    private readonly _defaultControls;
+    constructor(inputs: ToolbarWidgetGroupInputs<V>);
+}
+
+/** Represents the required inputs for a toolbar. */
+type ToolbarInputs<V> = Omit<ListInputs<ToolbarWidgetPattern<V> | ToolbarWidgetGroupPattern<V>, V>, 'multi' | 'typeaheadDelay' | 'value' | 'selectionMode' | 'focusMode'> & {
+    /** A function that returns the toolbar item associated with a given element. */
+    getItem: (e: Element) => ToolbarWidgetPattern<V> | ToolbarWidgetGroupPattern<V> | undefined;
+};
+/** Controls the state of a toolbar. */
+declare class ToolbarPattern<V> {
+    readonly inputs: ToolbarInputs<V>;
+    /** The list behavior for the toolbar. */
+    readonly listBehavior: List<ToolbarWidgetPattern<V> | ToolbarWidgetGroupPattern<V>, V>;
+    /** Whether the tablist is vertically or horizontally oriented. */
+    readonly orientation: SignalLike<'vertical' | 'horizontal'>;
+    /** Whether disabled items in the group should be skipped when navigating. */
+    readonly skipDisabled: SignalLike<boolean>;
+    /** Whether the toolbar is disabled. */
+    readonly disabled: _angular_core.Signal<boolean>;
+    /** The tabindex of the toolbar (if using activedescendant). */
+    readonly tabindex: _angular_core.Signal<0 | -1>;
+    /** The id of the current active widget (if using activedescendant). */
+    readonly activedescendant: _angular_core.Signal<string | undefined>;
+    /** The key used to navigate to the previous widget. */
+    private readonly _prevKey;
+    /** The key used to navigate to the next widget. */
+    private readonly _nextKey;
+    /** The alternate key used to navigate to the previous widget. */
+    private readonly _altPrevKey;
+    /** The alternate key used to navigate to the next widget. */
+    private readonly _altNextKey;
+    /** The keydown event manager for the toolbar. */
+    private readonly _keydown;
+    /** The pointerdown event manager for the toolbar. */
+    private readonly _pointerdown;
+    /** Navigates to the next widget in the toolbar. */
+    private _next;
+    /** Navigates to the previous widget in the toolbar. */
+    private _prev;
+    private _groupNext;
+    private _groupPrev;
+    /** Triggers the action of the currently active widget. */
+    private _trigger;
+    /** Navigates to the first widget in the toolbar. */
+    private _first;
+    /** Navigates to the last widget in the toolbar. */
+    private _last;
+    /** Navigates to the widget targeted by a pointer event. */
+    private _goto;
+    constructor(inputs: ToolbarInputs<V>);
+    /** Handles keydown events for the toolbar. */
+    onKeydown(event: KeyboardEvent): void;
+    /** Handles pointerdown events for the toolbar. */
+    onPointerdown(event: PointerEvent): void;
+    /**
+     * Sets the toolbar to its default initial state.
+     *
+     * Sets the active index to the selected widget if one exists and is focusable.
+     * Otherwise, sets the active index to the first focusable widget.
+     */
+    setDefaultState(): void;
+    /** Validates the state of the toolbar and returns a list of accessibility violations. */
+    validate(): string[];
+}
+
+export { ToolbarPattern, ToolbarWidgetGroupPattern, ToolbarWidgetPattern };
+export type { ToolbarInputs, ToolbarWidgetGroupControls, ToolbarWidgetGroupInputs, ToolbarWidgetInputs };

package/types/_tree-chunk.d.ts

@@ -0,0 +1,139 @@
+import * as _angular_core from '@angular/core';
+import { SignalLike } from './_list-navigation-chunk.js';
+import { ListItem, ListInputs, List } from './_list-chunk.js';
+import { ExpansionItem, ListExpansion, ExpansionControl } from './_expansion-chunk.js';
+import { KeyboardEventManager, PointerEventManager } from './_pointer-event-manager-chunk.js';
+
+/** Represents the required inputs for a tree item. */
+interface TreeItemInputs<V> extends Omit<ListItem<V>, 'index'> {
+    /** The parent item. */
+    parent: SignalLike<TreeItemPattern<V> | TreePattern<V>>;
+    /** Whether this item has children. Children can be lazily loaded. */
+    hasChildren: SignalLike<boolean>;
+    /** The children items. */
+    children: SignalLike<TreeItemPattern<V>[]>;
+    /** The tree pattern this item belongs to. */
+    tree: SignalLike<TreePattern<V>>;
+}
+interface TreeItemPattern<V> extends TreeItemInputs<V> {
+}
+/**
+ * Represents an item in a Tree.
+ */
+declare class TreeItemPattern<V> implements ExpansionItem {
+    readonly inputs: TreeItemInputs<V>;
+    /** The position of this item among its siblings. */
+    readonly index: _angular_core.Signal<number>;
+    /** The unique identifier used by the expansion behavior. */
+    readonly expansionId: SignalLike<string>;
+    /** Controls expansion for child items. */
+    readonly expansionManager: ListExpansion;
+    /** Controls expansion for this item. */
+    readonly expansion: ExpansionControl;
+    /** Whether the item is expandable. It's expandable if children item exist. */
+    readonly expandable: SignalLike<boolean>;
+    /** The level of the current item in a tree. */
+    readonly level: SignalLike<number>;
+    /** Whether this item is currently expanded. */
+    readonly expanded: _angular_core.Signal<boolean>;
+    /** Whether this item is visible. */
+    readonly visible: _angular_core.Signal<boolean>;
+    /** The number of items under the same parent at the same level. */
+    readonly setsize: _angular_core.Signal<number>;
+    /** The position of this item among its siblings (1-based). */
+    readonly posinset: _angular_core.Signal<number>;
+    /** Whether the item is active. */
+    readonly active: _angular_core.Signal<boolean>;
+    /** The tabindex of the item. */
+    readonly tabindex: _angular_core.Signal<0 | -1>;
+    /** Whether the item is selected. */
+    readonly selected: _angular_core.Signal<boolean | undefined>;
+    /** The current type of this item. */
+    readonly current: _angular_core.Signal<"page" | "step" | "location" | "date" | "time" | "true" | "false" | undefined>;
+    constructor(inputs: TreeItemInputs<V>);
+}
+/** The selection operations that the tree can perform. */
+interface SelectOptions {
+    toggle?: boolean;
+    selectOne?: boolean;
+    selectRange?: boolean;
+    anchor?: boolean;
+}
+/** Represents the required inputs for a tree. */
+interface TreeInputs<V> extends Omit<ListInputs<TreeItemPattern<V>, V>, 'items'> {
+    /** A unique identifier for the tree. */
+    id: SignalLike<string>;
+    /** All items in the tree, in document order (DFS-like, a flattened list). */
+    allItems: SignalLike<TreeItemPattern<V>[]>;
+    /** Whether the tree is in navigation mode. */
+    nav: SignalLike<boolean>;
+    /** The aria-current type. */
+    currentType: SignalLike<'page' | 'step' | 'location' | 'date' | 'time' | 'true' | 'false'>;
+}
+interface TreePattern<V> extends TreeInputs<V> {
+}
+/** Controls the state and interactions of a tree view. */
+declare class TreePattern<V> {
+    readonly inputs: TreeInputs<V>;
+    /** The list behavior for the tree. */
+    readonly listBehavior: List<TreeItemPattern<V>, V>;
+    /** Controls expansion for direct children of the tree root (top-level items). */
+    readonly expansionManager: ListExpansion;
+    /** The root level is 0. */
+    readonly level: () => number;
+    /** The root is always expanded. */
+    readonly expanded: () => boolean;
+    /** The tabindex of the tree. */
+    tabindex: SignalLike<-1 | 0>;
+    /** The id of the current active item. */
+    readonly activedescendant: _angular_core.Signal<string | undefined>;
+    /** The direct children of the root (top-level tree items). */
+    readonly children: _angular_core.Signal<TreeItemPattern<V>[]>;
+    /** All currently visible tree items. An item is visible if their parent is expanded. */
+    readonly visibleItems: _angular_core.Signal<TreeItemPattern<V>[]>;
+    /** Whether the tree selection follows focus. */
+    readonly followFocus: _angular_core.Signal<boolean>;
+    /** The key for navigating to the previous item. */
+    readonly prevKey: _angular_core.Signal<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
+    /** The key for navigating to the next item. */
+    readonly nextKey: _angular_core.Signal<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
+    /** The key for collapsing an item or moving to its parent. */
+    readonly collapseKey: _angular_core.Signal<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
+    /** The key for expanding an item or moving to its first child. */
+    readonly expandKey: _angular_core.Signal<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
+    /** Represents the space key. Does nothing when the user is actively using typeahead. */
+    readonly dynamicSpaceKey: _angular_core.Signal<"" | " ">;
+    /** Regular expression to match characters for typeahead. */
+    readonly typeaheadRegexp: RegExp;
+    /** The keydown event manager for the tree. */
+    readonly keydown: _angular_core.Signal<KeyboardEventManager<KeyboardEvent>>;
+    /** The pointerdown event manager for the tree. */
+    pointerdown: _angular_core.Signal<PointerEventManager<PointerEvent>>;
+    constructor(inputs: TreeInputs<V>);
+    /**
+     * Sets the tree to it's default initial state.
+     *
+     * Sets the active index of the tree to the first focusable selected tree item if one exists.
+     * Otherwise, sets focus to the first focusable tree item.
+     */
+    setDefaultState(): void;
+    /** Handles keydown events on the tree. */
+    onKeydown(event: KeyboardEvent): void;
+    /** Handles pointerdown events on the tree. */
+    onPointerdown(event: PointerEvent): void;
+    /** Navigates to the given tree item in the tree. */
+    goto(e: PointerEvent, opts?: SelectOptions): void;
+    /** Toggles to expand or collapse a tree item. */
+    toggleExpansion(item?: TreeItemPattern<V>): void;
+    /** Expands a tree item. */
+    expand(opts?: SelectOptions): void;
+    /** Expands all sibling tree items including itself. */
+    expandSiblings(item?: TreeItemPattern<V>): void;
+    /** Collapses a tree item. */
+    collapse(opts?: SelectOptions): void;
+    /** Retrieves the TreeItemPattern associated with a DOM event, if any. */
+    protected _getItem(event: Event): TreeItemPattern<V> | undefined;
+}
+
+export { TreeItemPattern, TreePattern };
+export type { TreeInputs, TreeItemInputs };

package/{accordion/index.d.ts → types/accordion.d.ts}

@@ -1,10 +1,11 @@
 import * as _angular_cdk_bidi from '@angular/cdk/bidi';
 import * as _angular_core from '@angular/core';
 import { WritableSignal } from '@angular/core';
-import { AccordionTriggerPattern, AccordionPanelPattern, AccordionGroupPattern } from '../accordion.d.js';
+import { AccordionTriggerPattern, AccordionPanelPattern, AccordionGroupPattern } from './_accordion-chunk.js';
 import * as i1 from '@angular/cdk-experimental/deferred-content';
-import '../pointer-event-manager.d.js';
-import '../expansion.d.js';
+import './_pointer-event-manager-chunk.js';
+import './_list-navigation-chunk.js';
+import './_expansion-chunk.js';
 
 /**
  * Represents the content panel of an accordion item. It is controlled by an

package/types/combobox.d.ts

@@ -0,0 +1,54 @@
+import * as _angular_core from '@angular/core';
+import { WritableSignal } from '@angular/core';
+import { ComboboxPattern, ComboboxListboxControls, ComboboxTreeControls } from './_combobox-chunk.js';
+import * as i1 from '@angular/cdk-experimental/deferred-content';
+import './_pointer-event-manager-chunk.js';
+import './_list-navigation-chunk.js';
+import './_list-chunk.js';
+
+declare class CdkCombobox<V> {
+    /** The element that the combobox is attached to. */
+    private readonly _elementRef;
+    /** The DeferredContentAware host directive. */
+    private readonly _deferredContentAware;
+    /** The combobox popup. */
+    readonly popup: _angular_core.Signal<CdkComboboxPopup<V> | undefined>;
+    /** The filter mode for the combobox. */
+    filterMode: _angular_core.InputSignal<"manual" | "auto-select" | "highlight">;
+    /** Whether the combobox is focused. */
+    readonly isFocused: WritableSignal<boolean>;
+    /** The value of the first matching item in the popup. */
+    firstMatch: _angular_core.InputSignal<V | undefined>;
+    /** Whether the listbox has received focus yet. */
+    private _hasBeenFocused;
+    /** The combobox ui pattern. */
+    readonly pattern: ComboboxPattern<any, V>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CdkCombobox<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkCombobox<any>, "[cdkCombobox]", ["cdkCombobox"], { "filterMode": { "alias": "filterMode"; "required": false; "isSignal": true; }; "firstMatch": { "alias": "firstMatch"; "required": false; "isSignal": true; }; }, {}, ["popup"], never, true, [{ directive: typeof i1.DeferredContentAware; inputs: { "preserveContent": "preserveContent"; }; outputs: {}; }]>;
+}
+declare class CdkComboboxInput {
+    /** The element that the combobox is attached to. */
+    private readonly _elementRef;
+    /** The combobox that the input belongs to. */
+    readonly combobox: CdkCombobox<any>;
+    /** The value of the input. */
+    value: _angular_core.ModelSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CdkComboboxInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkComboboxInput, "input[cdkComboboxInput]", ["cdkComboboxInput"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+declare class CdkComboboxPopupContainer {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CdkComboboxPopupContainer, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkComboboxPopupContainer, "ng-template[cdkComboboxPopupContainer]", ["cdkComboboxPopupContainer"], {}, {}, never, never, true, [{ directive: typeof i1.DeferredContent; inputs: {}; outputs: {}; }]>;
+}
+declare class CdkComboboxPopup<V> {
+    /** The combobox that the popup belongs to. */
+    readonly combobox: CdkCombobox<V> | null;
+    /** The controls the popup exposes to the combobox. */
+    readonly controls: WritableSignal<ComboboxListboxControls<any, V> | ComboboxTreeControls<any, V> | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CdkComboboxPopup<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkComboboxPopup<any>, "[cdkComboboxPopup]", ["cdkComboboxPopup"], {}, {}, never, never, true, never>;
+}
+
+export { CdkCombobox, CdkComboboxInput, CdkComboboxPopup, CdkComboboxPopupContainer };

package/{deferred-content/index.d.ts → types/deferred-content.d.ts}

@@ -4,10 +4,10 @@ import * as _angular_core from '@angular/core';
  * A container directive controls the visibility of its content.
  */
 declare class DeferredContentAware {
-    contentVisible: _angular_core.WritableSignal<boolean>;
-    readonly preserveContent: _angular_core.InputSignal<boolean>;
+    readonly contentVisible: _angular_core.WritableSignal<boolean>;
+    readonly preserveContent: _angular_core.ModelSignal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DeferredContentAware, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DeferredContentAware, never, never, { "preserveContent": { "alias": "preserveContent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DeferredContentAware, never, never, { "preserveContent": { "alias": "preserveContent"; "required": false; "isSignal": true; }; }, { "preserveContent": "preserveContentChange"; }, never, never, true, never>;
 }
 /**
  * DeferredContent loads/unloads the content based on the visibility.