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

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

@@ -1,8 +1,12 @@
-import * as _angular_core from '@angular/core';
 import * as _angular_cdk_bidi from '@angular/cdk/bidi';
-import { OptionPattern, ListboxPattern } from '../listbox.d.js';
-import '../pointer-event-manager.d.js';
-import '../list.d.js';
+import * as _angular_core from '@angular/core';
+import { OptionPattern, ListboxPattern } from './_listbox-chunk.js';
+import { CdkComboboxPopup } from './combobox.js';
+import './_list-navigation-chunk.js';
+import './_list-chunk.js';
+import './_pointer-event-manager-chunk.js';
+import './_combobox-chunk.js';
+import '@angular/cdk-experimental/deferred-content';
 
 /**
  * A listbox container.
@@ -19,6 +23,12 @@ import '../list.d.js';
  * ```
  */
 declare class CdkListbox<V> {
+    /** A unique identifier for the listbox. */
+    private readonly _generatedId;
+    /** A unique identifier for the listbox. */
+    protected id: _angular_core.Signal<string>;
+    /** A reference to the parent combobox popup, if one exists. */
+    private readonly _popup;
     /** A reference to the listbox element. */
     private readonly _elementRef;
     /** The directionality (LTR / RTL) context for the application (or a subtree of it). */
@@ -56,7 +66,7 @@ declare class CdkListbox<V> {
     constructor();
     onFocus(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CdkListbox<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkListbox<any>, "[cdkListbox]", ["cdkListbox"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "skipDisabled": { "alias": "skipDisabled"; "required": false; "isSignal": true; }; "focusMode": { "alias": "focusMode"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "typeaheadDelay": { "alias": "typeaheadDelay"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["_cdkOptions"], never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkListbox<any>, "[cdkListbox]", ["cdkListbox"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "skipDisabled": { "alias": "skipDisabled"; "required": false; "isSignal": true; }; "focusMode": { "alias": "focusMode"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "typeaheadDelay": { "alias": "typeaheadDelay"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["_cdkOptions"], never, true, [{ directive: typeof CdkComboboxPopup; inputs: {}; outputs: {}; }]>;
 }
 /** A selectable option in a CdkListbox. */
 declare class CdkOption<V> {

package/{radio-group/index.d.ts → types/radio-group.d.ts}

@@ -1,11 +1,11 @@
 import * as _angular_core from '@angular/core';
-import { WritableSignal, OnDestroy } from '@angular/core';
+import { WritableSignal } from '@angular/core';
 import * as _angular_cdk_bidi from '@angular/cdk/bidi';
-import { RadioGroupPattern } from '../radio-group.d.js';
-import { RadioButtonPattern } from '../toolbar.d.js';
-import { CdkToolbar } from '../toolbar/index.js';
-import '../pointer-event-manager.d.js';
-import '../list.d.js';
+import { RadioButtonPattern, RadioGroupPattern } from './_radio-group-chunk.js';
+import * as i1 from '@angular/cdk-experimental/toolbar';
+import './_pointer-event-manager-chunk.js';
+import './_list-navigation-chunk.js';
+import './_list-chunk.js';
 
 /**
  * A radio button group container.
@@ -25,42 +25,41 @@ import '../list.d.js';
 declare class CdkRadioGroup<V> {
     /** A reference to the radio group element. */
     private readonly _elementRef;
+    /** A reference to the CdkToolbarWidgetGroup, if the radio group is in a toolbar. */
+    private readonly _cdkToolbarWidgetGroup;
+    /** Whether the radio group is inside of a CdkToolbar. */
+    private readonly _hasToolbar;
     /** The CdkRadioButtons nested inside of the CdkRadioGroup. */
     private readonly _cdkRadioButtons;
     /** A signal wrapper for directionality. */
     protected textDirection: WritableSignal<_angular_cdk_bidi.Direction>;
-    /** A signal wrapper for toolbar. */
-    toolbar: CdkToolbar<any> | null;
-    /** Toolbar pattern if applicable */
-    private readonly _toolbarPattern;
     /** The RadioButton UIPatterns of the child CdkRadioButtons. */
     protected items: _angular_core.Signal<RadioButtonPattern<any>[]>;
     /** Whether the radio group is vertically or horizontally oriented. */
-    orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
     /** Whether disabled items in the group should be skipped when navigating. */
-    skipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly skipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** The focus strategy used by the radio group. */
-    focusMode: _angular_core.InputSignal<"roving" | "activedescendant">;
+    readonly focusMode: _angular_core.InputSignal<"roving" | "activedescendant">;
     /** Whether the radio group is disabled. */
-    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the radio group is readonly. */
-    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** The value of the currently selected radio button. */
-    value: _angular_core.ModelSignal<V | null>;
+    readonly value: _angular_core.ModelSignal<V | null>;
     /** The internal selection state for the radio group. */
     private readonly _value;
     /** The RadioGroup UIPattern. */
-    pattern: RadioGroupPattern<V>;
+    readonly pattern: RadioGroupPattern<V>;
     /** Whether the radio group has received focus yet. */
     private _hasFocused;
     constructor();
     onFocus(): void;
-    toolbarButtonUnregister(radio: CdkRadioButton<V>): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CdkRadioGroup<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkRadioGroup<any>, "[cdkRadioGroup]", ["cdkRadioGroup"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "skipDisabled": { "alias": "skipDisabled"; "required": false; "isSignal": true; }; "focusMode": { "alias": "focusMode"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["_cdkRadioButtons"], never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkRadioGroup<any>, "[cdkRadioGroup]", ["cdkRadioGroup"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "skipDisabled": { "alias": "skipDisabled"; "required": false; "isSignal": true; }; "focusMode": { "alias": "focusMode"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["_cdkRadioButtons"], never, true, [{ directive: typeof i1.CdkToolbarWidgetGroup; inputs: { "disabled": "disabled"; }; outputs: {}; }]>;
 }
 /** A selectable radio button in a CdkRadioGroup. */
-declare class CdkRadioButton<V> implements OnDestroy {
+declare class CdkRadioButton<V> {
     /** A reference to the radio button element. */
     private readonly _elementRef;
     /** The parent CdkRadioGroup. */
@@ -68,18 +67,17 @@ declare class CdkRadioButton<V> implements OnDestroy {
     /** A unique identifier for the radio button. */
     private readonly _generatedId;
     /** A unique identifier for the radio button. */
-    protected id: _angular_core.Signal<string>;
+    readonly id: _angular_core.Signal<string>;
     /** The value associated with the radio button. */
     readonly value: _angular_core.InputSignal<V>;
     /** The parent RadioGroup UIPattern. */
-    protected group: _angular_core.Signal<RadioGroupPattern<any>>;
+    readonly group: _angular_core.Signal<RadioGroupPattern<any>>;
     /** A reference to the radio button element to be focused on navigation. */
     element: _angular_core.Signal<any>;
     /** Whether the radio button is disabled. */
     disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** The RadioButton UIPattern. */
     pattern: RadioButtonPattern<V>;
-    ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CdkRadioButton<any>, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkRadioButton<any>, "[cdkRadioButton]", ["cdkRadioButton"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -1,11 +1,12 @@
 import * as _angular_core from '@angular/core';
 import { Signal, OnInit, OnDestroy } from '@angular/core';
 import * as _angular_cdk_bidi from '@angular/cdk/bidi';
-import { TabPattern, TabPanelPattern, TabListPattern } from '../tabs.d.js';
+import { TabPattern, TabPanelPattern, TabListPattern } from './_tabs-chunk.js';
 import * as i1 from '@angular/cdk-experimental/deferred-content';
-import '../pointer-event-manager.d.js';
-import '../expansion.d.js';
-import '../list.d.js';
+import './_pointer-event-manager-chunk.js';
+import './_list-navigation-chunk.js';
+import './_expansion-chunk.js';
+import './_list-chunk.js';
 
 interface HasElement {
     element: Signal<HTMLElement>;

package/types/toolbar.d.ts

@@ -0,0 +1,115 @@
+import * as _angular_core from '@angular/core';
+import { Signal, OnInit, OnDestroy } from '@angular/core';
+import * as _angular_cdk_bidi from '@angular/cdk/bidi';
+import { ToolbarWidgetPattern, ToolbarWidgetGroupPattern, ToolbarPattern, ToolbarWidgetGroupControls } from './_toolbar-chunk.js';
+import './_list-navigation-chunk.js';
+import './_list-chunk.js';
+
+/**
+ * A toolbar widget container.
+ *
+ * Widgets such as radio groups or buttons are nested within a toolbar to allow for a single
+ * place of reference for focus and navigation. The CdkToolbar is meant to be used in conjunction
+ * with CdkToolbarWidget and CdkRadioGroup as follows:
+ *
+ * ```html
+ * <div cdkToolbar>
+ *  <button cdkToolbarWidget>Button</button>
+ *  <div cdkRadioGroup>
+ *    <label cdkRadioButton value="1">Option 1</label>
+ *    <label cdkRadioButton value="2">Option 2</label>
+ *    <label cdkRadioButton value="3">Option 3</label>
+ *  </div>
+ * </div>
+ * ```
+ */
+declare class CdkToolbar<V> {
+    /** A reference to the toolbar element. */
+    private readonly _elementRef;
+    /** The CdkTabList nested inside of the container. */
+    private readonly _cdkWidgets;
+    /** A signal wrapper for directionality. */
+    readonly textDirection: _angular_core.WritableSignal<_angular_cdk_bidi.Direction>;
+    /** Sorted UIPatterns of the child widgets */
+    readonly items: Signal<(ToolbarWidgetPattern<V> | ToolbarWidgetGroupPattern<V>)[]>;
+    /** Whether the toolbar is vertically or horizontally oriented. */
+    readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    /** Whether disabled items in the group should be skipped when navigating. */
+    readonly skipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the toolbar is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether focus should wrap when navigating. */
+    readonly wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The toolbar UIPattern. */
+    readonly pattern: ToolbarPattern<V>;
+    /** Whether the toolbar has received focus yet. */
+    private _hasFocused;
+    constructor();
+    onFocus(): void;
+    register(widget: CdkToolbarWidget<V> | CdkToolbarWidgetGroup<V>): void;
+    unregister(widget: CdkToolbarWidget<V> | CdkToolbarWidgetGroup<V>): void;
+    /** Finds the toolbar item associated with a given element. */
+    private _getItem;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CdkToolbar<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkToolbar<any>, "[cdkToolbar]", ["cdkToolbar"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "skipDisabled": { "alias": "skipDisabled"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * A widget within a toolbar.
+ *
+ * A widget is anything that is within a toolbar. It should be applied to any native HTML element
+ * that has the purpose of acting as a widget navigatable within a toolbar.
+ */
+declare class CdkToolbarWidget<V> implements OnInit, OnDestroy {
+    /** A reference to the widget element. */
+    private readonly _elementRef;
+    /** The parent CdkToolbar. */
+    private readonly _cdkToolbar;
+    /** A unique identifier for the widget. */
+    private readonly _generatedId;
+    /** A unique identifier for the widget. */
+    readonly id: Signal<string>;
+    /** The parent Toolbar UIPattern. */
+    readonly toolbar: Signal<ToolbarPattern<any>>;
+    /** A reference to the widget element to be focused on navigation. */
+    readonly element: Signal<any>;
+    /** Whether the widget is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the widget is 'hard' disabled, which is different from `aria-disabled`. A hard disabled widget cannot receive focus. */
+    readonly hardDisabled: Signal<boolean>;
+    /** The ToolbarWidget UIPattern. */
+    readonly pattern: ToolbarWidgetPattern<V>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CdkToolbarWidget<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkToolbarWidget<any>, "[cdkToolbarWidget]", ["cdkToolbarWidget"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * A directive that groups toolbar widgets, used for more complex widgets like radio groups that
+ * have their own internal navigation.
+ */
+declare class CdkToolbarWidgetGroup<V> implements OnInit, OnDestroy {
+    /** A reference to the widget element. */
+    private readonly _elementRef;
+    /** The parent CdkToolbar. */
+    private readonly _cdkToolbar;
+    /** A unique identifier for the widget. */
+    private readonly _generatedId;
+    /** A unique identifier for the widget. */
+    readonly id: Signal<string>;
+    /** The parent Toolbar UIPattern. */
+    readonly toolbar: Signal<ToolbarPattern<any> | undefined>;
+    /** A reference to the widget element to be focused on navigation. */
+    readonly element: Signal<any>;
+    /** Whether the widget group is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The controls that can be performed on the widget group. */
+    readonly controls: _angular_core.WritableSignal<ToolbarWidgetGroupControls | undefined>;
+    /** The ToolbarWidgetGroup UIPattern. */
+    readonly pattern: ToolbarWidgetGroupPattern<V>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CdkToolbarWidgetGroup<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkToolbarWidgetGroup<any>, never, never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { CdkToolbar, CdkToolbarWidget, CdkToolbarWidgetGroup };

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

@@ -1,139 +1,13 @@
 import * as _angular_cdk_bidi from '@angular/cdk/bidi';
 import * as _angular_core from '@angular/core';
-import { OnInit, OnDestroy, Signal } from '@angular/core';
-import { SignalLike, KeyboardEventManager, PointerEventManager } from '../pointer-event-manager.d.js';
-import { List, ListItem, ListInputs } from '../list.d.js';
-import { ExpansionItem, ListExpansion, ExpansionControl } from '../expansion.d.js';
-import * as i1 from '@angular/cdk-experimental/deferred-content';
-
-/** 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'> {
-    /** 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. */
-    readonly tabindex: _angular_core.Signal<0 | -1>;
-    /** 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. */
-    private _getItem;
-}
+import { Signal, OnInit, OnDestroy } from '@angular/core';
+import { TreePattern, TreeItemPattern } from './_tree-chunk.js';
+import * as i1 from '@angular/cdk-experimental/combobox';
+import * as i1$1 from '@angular/cdk-experimental/deferred-content';
+import './_list-navigation-chunk.js';
+import './_list-chunk.js';
+import './_expansion-chunk.js';
+import './_pointer-event-manager-chunk.js';
 
 interface HasElement {
     element: Signal<HTMLElement>;
@@ -160,6 +34,12 @@ interface HasElement {
  * ```
  */
 declare class CdkTree<V> {
+    /** A unique identifier for the tree. */
+    private readonly _generatedId;
+    /** A unique identifier for the tree. */
+    protected id: Signal<string>;
+    /** A reference to the parent combobox popup, if one exists. */
+    private readonly _popup;
     /** A reference to the tree element. */
     private readonly _elementRef;
     /** All CdkTreeItem instances within this tree. */
@@ -197,7 +77,7 @@ declare class CdkTree<V> {
     register(child: CdkTreeItem<V>): void;
     unregister(child: CdkTreeItem<V>): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CdkTree<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkTree<any>, "[cdkTree]", ["cdkTree"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "focusMode": { "alias": "focusMode"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "skipDisabled": { "alias": "skipDisabled"; "required": false; "isSignal": true; }; "typeaheadDelay": { "alias": "typeaheadDelay"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "nav": { "alias": "nav"; "required": false; "isSignal": true; }; "currentType": { "alias": "currentType"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkTree<any>, "[cdkTree]", ["cdkTree"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "focusMode": { "alias": "focusMode"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "skipDisabled": { "alias": "skipDisabled"; "required": false; "isSignal": true; }; "typeaheadDelay": { "alias": "typeaheadDelay"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "nav": { "alias": "nav"; "required": false; "isSignal": true; }; "currentType": { "alias": "currentType"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, [{ directive: typeof i1.CdkComboboxPopup; inputs: {}; outputs: {}; }]>;
 }
 /**
  * A selectable and expandable Tree Item in a Tree.
@@ -261,7 +141,7 @@ declare class CdkTreeItemGroup<V> implements OnInit, OnDestroy, HasElement {
     register(child: CdkTreeItem<V>): void;
     unregister(child: CdkTreeItem<V>): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CdkTreeItemGroup<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkTreeItemGroup<any>, "[cdkTreeItemGroup]", ["cdkTreeItemGroup"], { "ownedBy": { "alias": "ownedBy"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.DeferredContentAware; inputs: { "preserveContent": "preserveContent"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkTreeItemGroup<any>, "[cdkTreeItemGroup]", ["cdkTreeItemGroup"], { "ownedBy": { "alias": "ownedBy"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.DeferredContentAware; inputs: { "preserveContent": "preserveContent"; }; outputs: {}; }]>;
 }
 /**
  * A structural directive that marks the `ng-template` to be used as the content
@@ -269,7 +149,7 @@ declare class CdkTreeItemGroup<V> implements OnInit, OnDestroy, HasElement {
  */
 declare class CdkTreeItemGroupContent {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CdkTreeItemGroupContent, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkTreeItemGroupContent, "ng-template[cdkTreeItemGroupContent]", never, {}, {}, never, never, true, [{ directive: typeof i1.DeferredContent; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkTreeItemGroupContent, "ng-template[cdkTreeItemGroupContent]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.DeferredContent; inputs: {}; outputs: {}; }]>;
 }
 
 export { CdkTree, CdkTreeItem, CdkTreeItemGroup, CdkTreeItemGroupContent };

package/types/ui-patterns.d.ts

@@ -0,0 +1,157 @@
+import { ComboboxPattern, ComboboxListboxControls, ComboboxTreeControls } from './_combobox-chunk.js';
+export { ComboboxInputs } from './_combobox-chunk.js';
+import { ListboxInputs, OptionPattern, ListboxPattern } from './_listbox-chunk.js';
+export { OptionInputs } from './_listbox-chunk.js';
+import * as _angular_core from '@angular/core';
+import { SignalLike } from './_list-navigation-chunk.js';
+export { WritableSignalLike, convertGetterSetterToWritableSignalLike } from './_list-navigation-chunk.js';
+import { RadioGroupInputs, RadioGroupPattern } from './_radio-group-chunk.js';
+export { RadioButtonInputs, RadioButtonPattern } from './_radio-group-chunk.js';
+import { ToolbarPattern, ToolbarWidgetGroupControls } from './_toolbar-chunk.js';
+export { ToolbarInputs, ToolbarWidgetGroupInputs, ToolbarWidgetGroupPattern, ToolbarWidgetInputs, ToolbarWidgetPattern } from './_toolbar-chunk.js';
+export { TabInputs, TabListInputs, TabListPattern, TabPanelInputs, TabPanelPattern, TabPattern } from './_tabs-chunk.js';
+export { AccordionGroupInputs, AccordionGroupPattern, AccordionPanelInputs, AccordionPanelPattern, AccordionTriggerInputs, AccordionTriggerPattern } from './_accordion-chunk.js';
+import { TreeInputs, TreeItemPattern, TreePattern } from './_tree-chunk.js';
+export { TreeItemInputs } from './_tree-chunk.js';
+import './_pointer-event-manager-chunk.js';
+import './_list-chunk.js';
+import './_expansion-chunk.js';
+
+type ComboboxListboxInputs<V> = ListboxInputs<V> & {
+    /** The combobox controlling the listbox. */
+    combobox: SignalLike<ComboboxPattern<OptionPattern<V>, V> | undefined>;
+};
+declare class ComboboxListboxPattern<V> extends ListboxPattern<V> implements ComboboxListboxControls<OptionPattern<V>, V> {
+    readonly inputs: ComboboxListboxInputs<V>;
+    /** A unique identifier for the popup. */
+    id: _angular_core.Signal<string>;
+    /** The ARIA role for the listbox. */
+    role: _angular_core.Signal<"listbox">;
+    /** The id of the active (focused) item in the listbox. */
+    activeId: _angular_core.Signal<string | undefined>;
+    /** The list of options in the listbox. */
+    items: SignalLike<OptionPattern<V>[]>;
+    /** The tabindex for the listbox. Always -1 because the combobox handles focus. */
+    tabindex: SignalLike<-1 | 0>;
+    constructor(inputs: ComboboxListboxInputs<V>);
+    /** Noop. The combobox handles keydown events. */
+    onKeydown(_: KeyboardEvent): void;
+    /** Noop. The combobox handles pointerdown events. */
+    onPointerdown(_: PointerEvent): void;
+    /** Noop. The combobox controls the open state. */
+    setDefaultState(): void;
+    /** Navigates to the specified item in the listbox. */
+    focus: (item: OptionPattern<V>) => void;
+    /** Navigates to the next focusable item in the listbox. */
+    next: () => void;
+    /** Navigates to the previous focusable item in the listbox. */
+    prev: () => void;
+    /** Navigates to the last focusable item in the listbox. */
+    last: () => void;
+    /** Navigates to the first focusable item in the listbox. */
+    first: () => void;
+    /** Unfocuses the currently focused item in the listbox. */
+    unfocus: () => void;
+    /** Selects the specified item in the listbox. */
+    select: (item?: OptionPattern<V>) => void;
+    /** Clears the selection in the listbox. */
+    clearSelection: () => void;
+    /** Retrieves the OptionPattern associated with a pointer event. */
+    getItem: (e: PointerEvent) => OptionPattern<V> | undefined;
+    /** Retrieves the currently selected item in the listbox. */
+    getSelectedItem: () => OptionPattern<V> | undefined;
+    /** Sets the value of the combobox listbox. */
+    setValue: (value: V | undefined) => void;
+}
+
+/** Represents the required inputs for a toolbar controlled radio group. */
+type ToolbarRadioGroupInputs<V> = RadioGroupInputs<V> & {
+    /** The toolbar controlling the radio group. */
+    toolbar: SignalLike<ToolbarPattern<V> | undefined>;
+};
+/** Controls the state of a radio group in a toolbar. */
+declare class ToolbarRadioGroupPattern<V> extends RadioGroupPattern<V> implements ToolbarWidgetGroupControls {
+    readonly inputs: ToolbarRadioGroupInputs<V>;
+    constructor(inputs: ToolbarRadioGroupInputs<V>);
+    /** Noop. The toolbar handles keydown events. */
+    onKeydown(_: KeyboardEvent): void;
+    /** Noop. The toolbar handles pointerdown events. */
+    onPointerdown(_: PointerEvent): void;
+    /** Whether the radio group is currently on the first item. */
+    isOnFirstItem(): boolean;
+    /** Whether the radio group is currently on the last item. */
+    isOnLastItem(): boolean;
+    /** Navigates to the next radio button in the group. */
+    next(wrap: boolean): void;
+    /** Navigates to the previous radio button in the group. */
+    prev(wrap: boolean): void;
+    /** Navigates to the first radio button in the group. */
+    first(): void;
+    /** Navigates to the last radio button in the group. */
+    last(): void;
+    /** Removes focus from the radio group. */
+    unfocus(): void;
+    /** Triggers the action of the currently active radio button in the group. */
+    trigger(): void;
+    /** Navigates to the radio button targeted by a pointer event. */
+    goto(e: PointerEvent): void;
+}
+
+type ComboboxTreeInputs<V> = TreeInputs<V> & {
+    /** The combobox controlling the tree. */
+    combobox: SignalLike<ComboboxPattern<TreeItemPattern<V>, V> | undefined>;
+};
+declare class ComboboxTreePattern<V> extends TreePattern<V> implements ComboboxTreeControls<TreeItemPattern<V>, V> {
+    readonly inputs: ComboboxTreeInputs<V>;
+    /** Whether the currently focused item is collapsible. */
+    isItemCollapsible: () => boolean;
+    /** The ARIA role for the tree. */
+    role: () => "tree";
+    activeId: _angular_core.Signal<string | undefined>;
+    /** The list of items in the tree. */
+    items: _angular_core.Signal<TreeItemPattern<V>[]>;
+    /** The tabindex for the tree. Always -1 because the combobox handles focus. */
+    tabindex: SignalLike<-1 | 0>;
+    constructor(inputs: ComboboxTreeInputs<V>);
+    /** Noop. The combobox handles keydown events. */
+    onKeydown(_: KeyboardEvent): void;
+    /** Noop. The combobox handles pointerdown events. */
+    onPointerdown(_: PointerEvent): void;
+    /** Noop. The combobox controls the open state. */
+    setDefaultState(): void;
+    /** Navigates to the specified item in the tree. */
+    focus: (item: TreeItemPattern<V>) => void;
+    /** Navigates to the next focusable item in the tree. */
+    next: () => void;
+    /** Navigates to the previous focusable item in the tree. */
+    prev: () => void;
+    /** Navigates to the last focusable item in the tree. */
+    last: () => void;
+    /** Navigates to the first focusable item in the tree. */
+    first: () => void;
+    /** Unfocuses the currently focused item in the tree. */
+    unfocus: () => void;
+    /** Selects the specified item in the tree or the current active item if not provided. */
+    select: (item?: TreeItemPattern<V>) => void;
+    /** Clears the selection in the tree. */
+    clearSelection: () => void;
+    /** Retrieves the TreeItemPattern associated with a pointer event. */
+    getItem: (e: PointerEvent) => TreeItemPattern<V> | undefined;
+    /** Retrieves the currently selected item in the tree */
+    getSelectedItem: () => TreeItemPattern<V> | undefined;
+    /** Sets the value of the combobox tree. */
+    setValue: (value: V | undefined) => void;
+    /** Expands the currently focused item if it is expandable. */
+    expandItem: () => void;
+    /** Collapses the currently focused item if it is expandable. */
+    collapseItem: () => void;
+    /** Whether the specified item or the currently active item is expandable. */
+    isItemExpandable(item?: TreeItemPattern<V> | undefined): boolean;
+    /** Expands all of the tree items. */
+    expandAll: () => void;
+    /** Collapses all of the tree items. */
+    collapseAll: () => void;
+}
+
+export { ComboboxListboxControls, ComboboxListboxPattern, ComboboxPattern, ComboboxTreeControls, ComboboxTreePattern, ListboxInputs, ListboxPattern, OptionPattern, RadioGroupInputs, RadioGroupPattern, SignalLike, ToolbarPattern, ToolbarRadioGroupPattern, ToolbarWidgetGroupControls, TreeInputs, TreeItemPattern, TreePattern };
+export type { ComboboxListboxInputs, ComboboxTreeInputs, ToolbarRadioGroupInputs };