@angular/cdk-experimental 20.2.0-next.2 → 20.2.0-rc.0

package/{listbox.d-Ckp1is82.d.ts → listbox.d.d.ts}

@@ -1,19 +1,17 @@
 import * as _angular_core from '@angular/core';
-import { a as ListSelectionItem, L as ListSelection, b as ListSelectionInputs } from './list-selection.d-fbAPr_N_.js';
-import { a as ListTypeaheadItem, b as ListTypeaheadInputs, L as ListTypeahead } from './list-typeahead.d-ljh3nJ9y.js';
-import { e as ListNavigationItem, f as ListFocusItem, S as SignalLike, d as ListFocus, b as ListNavigation, L as ListNavigationInputs, a as ListFocusInputs, K as KeyboardEventManager, P as PointerEventManager } from './pointer-event-manager.d-BqSm9Jh5.js';
+import { SignalLike, KeyboardEventManager, PointerEventManager } from './pointer-event-manager.d.js';
+import { ListItem, ListInputs, List } from './list.d.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> {
-    focusManager: ListFocus<OptionPattern<V>>;
-    selection: ListSelection<OptionPattern<V>, V>;
-    navigation: ListNavigation<OptionPattern<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 ListNavigationItem, ListSelectionItem<V>, ListTypeaheadItem, ListFocusItem {
+interface OptionInputs<V> extends Omit<ListItem<V>, 'index'> {
     listbox: SignalLike<ListboxPattern$1<V> | undefined>;
 }
 /** Represents an option in a listbox. */
@@ -41,28 +39,14 @@ declare class OptionPattern<V> {
     constructor(args: OptionInputs<V>);
 }
 
-/** The selection operations that the listbox can perform. */
-interface SelectOptions {
-    toggle?: boolean;
-    selectOne?: boolean;
-    selectRange?: boolean;
-    anchor?: boolean;
-}
 /** Represents the required inputs for a listbox. */
-type ListboxInputs<V> = ListNavigationInputs<OptionPattern<V>> & ListSelectionInputs<OptionPattern<V>, V> & ListTypeaheadInputs<OptionPattern<V>> & ListFocusInputs<OptionPattern<V>> & {
+type ListboxInputs<V> = ListInputs<OptionPattern<V>, V> & {
     readonly: SignalLike<boolean>;
 };
 /** Controls the state of a listbox. */
 declare class ListboxPattern<V> {
     readonly inputs: ListboxInputs<V>;
-    /** Controls navigation for the listbox. */
-    navigation: ListNavigation<OptionPattern<V>>;
-    /** Controls selection for the listbox. */
-    selection: ListSelection<OptionPattern<V>, V>;
-    /** Controls typeahead for the listbox. */
-    typeahead: ListTypeahead<OptionPattern<V>>;
-    /** Controls focus for the listbox. */
-    focusManager: ListFocus<OptionPattern<V>>;
+    listBehavior: List<OptionPattern<V>, V>;
     /** Whether the list is vertically or horizontally oriented. */
     orientation: SignalLike<'vertical' | 'horizontal'>;
     /** Whether the listbox is disabled. */
@@ -89,19 +73,6 @@ declare class ListboxPattern<V> {
     dynamicSpaceKey: _angular_core.Signal<"" | " ">;
     /** The regexp used to decide if a key should trigger typeahead. */
     typeaheadRegexp: RegExp;
-    /**
-     * The uncommitted index for selecting a range of options.
-     *
-     * NOTE: This is subtly distinct from the "rangeStartIndex" in the ListSelection behavior.
-     * The anchorIndex does not necessarily represent the start of a range, but represents the most
-     * recent index where the user showed intent to begin a range selection. Usually, this is wherever
-     * the user most recently pressed the "Shift" key, but if the user presses shift + space to select
-     * from the anchor, the user is not intending to start a new range from this index.
-     *
-     * In other words, "rangeStartIndex" is only set when a user commits to starting a range selection
-     * while "anchorIndex" is set whenever a user indicates they may be starting a range selection.
-     */
-    anchorIndex: _angular_core.WritableSignal<number>;
     /** The keydown event manager for the listbox. */
     keydown: _angular_core.Signal<KeyboardEventManager<KeyboardEvent>>;
     /** The pointerdown event manager for the listbox. */
@@ -112,18 +83,6 @@ declare class ListboxPattern<V> {
     /** Handles keydown events for the listbox. */
     onKeydown(event: KeyboardEvent): void;
     onPointerdown(event: PointerEvent): void;
-    /** Navigates to the first option in the listbox. */
-    first(opts?: SelectOptions): void;
-    /** Navigates to the last option in the listbox. */
-    last(opts?: SelectOptions): void;
-    /** Navigates to the next option in the listbox. */
-    next(opts?: SelectOptions): void;
-    /** Navigates to the previous option in the listbox. */
-    prev(opts?: SelectOptions): void;
-    /** Navigates to the given item in the listbox. */
-    goto(event: PointerEvent, opts?: SelectOptions): void;
-    /** Handles typeahead search navigation for the listbox. */
-    search(char: string, opts?: SelectOptions): void;
     /**
      * Sets the listbox to it's default initial state.
      *
@@ -135,20 +94,8 @@ declare class ListboxPattern<V> {
      * is called.
      */
     setDefaultState(): void;
-    /**
-     * Safely performs a navigation operation.
-     *
-     * Handles conditionally disabling wrapping for when a navigation
-     * operation is occurring while the user is selecting a range of options.
-     *
-     * Handles boilerplate calling of focus & selection operations. Also ensures these
-     * additional operations are only called if the navigation operation moved focus to a new option.
-     */
-    private _navigate;
-    /** Handles updating selection for the listbox. */
-    private _updateSelection;
     private _getItem;
 }
 
-export { ListboxPattern as a, OptionPattern as b };
-export type { ListboxInputs as L, OptionInputs as O };
+export { ListboxPattern, OptionPattern };
+export type { ListboxInputs, OptionInputs };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/cdk-experimental",
-  "version": "20.2.0-next.2",
+  "version": "20.2.0-rc.0",
   "description": "Experimental components for Angular CDK",
   "repository": {
     "type": "git",
@@ -12,7 +12,7 @@
   },
   "homepage": "https://github.com/angular/components#readme",
   "peerDependencies": {
-    "@angular/cdk": "20.2.0-next.2",
+    "@angular/cdk": "20.2.0-rc.0",
     "@angular/core": "^20.0.0-0 || ^20.1.0-0 || ^20.2.0-0 || ^20.3.0-0 || ^21.0.0-0"
   },
   "devDependencies": {
@@ -88,6 +88,10 @@
       "types": "./tabs/index.d.ts",
       "default": "./fesm2022/tabs.mjs"
     },
+    "./toolbar": {
+      "types": "./toolbar/index.d.ts",
+      "default": "./fesm2022/toolbar.mjs"
+    },
     "./tree": {
       "types": "./tree/index.d.ts",
       "default": "./fesm2022/tree.mjs"

package/{pointer-event-manager.d-BqSm9Jh5.d.ts → pointer-event-manager.d.d.ts}

@@ -16,6 +16,8 @@ interface ListFocusItem {
     element: SignalLike<HTMLElement>;
     /** 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> {
@@ -25,18 +27,20 @@ interface ListFocusInputs<T extends ListFocusItem> {
     disabled: SignalLike<boolean>;
     /** The items in the list. */
     items: SignalLike<T[]>;
-    /** The index of the current active item. */
-    activeIndex: WritableSignalLike<number>;
+    /** The active item. */
+    activeItem: WritableSignalLike<T | undefined>;
     /** Whether disabled items in the list should be skipped when navigating. */
     skipDisabled: SignalLike<boolean>;
 }
 /** Controls focus for a list of items. */
 declare class ListFocus<T extends ListFocusItem> {
     readonly inputs: ListFocusInputs<T>;
-    /** The last index that was active. */
-    prevActiveIndex: _angular_core.WritableSignal<number>;
-    /** The current active item. */
-    activeItem: _angular_core.Signal<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;
@@ -181,5 +185,5 @@ declare class PointerEventManager<T extends PointerEvent> extends EventManager<T
     _isMatch(event: PointerEvent, button: MouseButton, modifiers: ModifierInputs): boolean;
 }
 
-export { KeyboardEventManager as K, PointerEventManager as P, ListNavigation as b, convertGetterSetterToWritableSignalLike as c, ListFocus as d };
-export type { ListNavigationInputs as L, SignalLike as S, WritableSignalLike as W, ListFocusInputs as a, ListNavigationItem as e, ListFocusItem as f };
+export { KeyboardEventManager, ListFocus, ListNavigation, PointerEventManager, convertGetterSetterToWritableSignalLike };
+export type { ListFocusInputs, ListFocusItem, ListNavigationInputs, ListNavigationItem, SignalLike, WritableSignalLike };

package/radio-group/index.d.ts

@@ -1,9 +1,11 @@
 import * as _angular_core from '@angular/core';
-import { WritableSignal } from '@angular/core';
+import { WritableSignal, OnDestroy } from '@angular/core';
 import * as _angular_cdk_bidi from '@angular/cdk/bidi';
-import { c as RadioButtonPattern, a as RadioGroupPattern } from '../radio-group.d-CFC0aKQM.js';
-import '../pointer-event-manager.d-BqSm9Jh5.js';
-import '../list-selection.d-fbAPr_N_.js';
+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';
 
 /**
  * A radio button group container.
@@ -25,6 +27,10 @@ declare class CdkRadioGroup<V> {
     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. */
@@ -47,11 +53,12 @@ declare class CdkRadioGroup<V> {
     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>;
 }
 /** A selectable radio button in a CdkRadioGroup. */
-declare class CdkRadioButton<V> {
+declare class CdkRadioButton<V> implements OnDestroy {
     /** A reference to the radio button element. */
     private readonly _elementRef;
     /** The parent CdkRadioGroup. */
@@ -61,15 +68,16 @@ declare class CdkRadioButton<V> {
     /** A unique identifier for the radio button. */
     protected id: _angular_core.Signal<string>;
     /** The value associated with the radio button. */
-    protected value: _angular_core.InputSignal<V>;
+    readonly value: _angular_core.InputSignal<V>;
     /** The parent RadioGroup UIPattern. */
     protected group: _angular_core.Signal<RadioGroupPattern<any>>;
     /** A reference to the radio button element to be focused on navigation. */
-    protected element: _angular_core.Signal<any>;
+    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/radio-group.d.d.ts

@@ -0,0 +1,80 @@
+import * as _angular_core from '@angular/core';
+import { SignalLike, KeyboardEventManager, PointerEventManager } from './pointer-event-manager.d.js';
+import { ListInputs, List } from './list.d.js';
+import { RadioButtonPattern } from './toolbar.d.js';
+
+/** 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>;
+    /** Parent toolbar of radio group */
+    toolbar: SignalLike<ToolbarLike<V> | undefined>;
+};
+/**
+ * Represents the properties exposed by a toolbar widget that need to be accessed by a radio group.
+ * This exists to avoid circular dependency errors between the toolbar and radio button.
+ */
+type ToolbarWidgetLike = {
+    id: SignalLike<string>;
+    index: SignalLike<number>;
+    element: SignalLike<HTMLElement>;
+    disabled: SignalLike<boolean>;
+    searchTerm: SignalLike<any>;
+    value: SignalLike<any>;
+};
+/**
+ * Represents the properties exposed by a toolbar that need to be accessed by a radio group.
+ * This exists to avoid circular dependency errors between the toolbar and radio button.
+ */
+interface ToolbarLike<V> {
+    listBehavior: List<RadioButtonPattern<V> | ToolbarWidgetLike, V>;
+    orientation: SignalLike<'vertical' | 'horizontal'>;
+    disabled: SignalLike<boolean>;
+}
+/** 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> | ToolbarWidgetLike, V>;
+    /** Whether the radio group is vertically or horizontally oriented. */
+    orientation: SignalLike<'vertical' | 'horizontal'>;
+    /** Whether the radio group is disabled. */
+    disabled: _angular_core.Signal<boolean>;
+    /** The currently selected radio button. */
+    selectedItem: _angular_core.Signal<ToolbarWidgetLike | RadioButtonPattern<V>>;
+    /** Whether the radio group is readonly. */
+    readonly: _angular_core.Signal<boolean>;
+    /** The tabindex of the radio group. */
+    tabindex: _angular_core.Signal<0 | -1>;
+    /** The id of the current active radio button (if using activedescendant). */
+    activedescendant: _angular_core.Signal<string | undefined>;
+    /** The key used to navigate to the previous radio button. */
+    prevKey: _angular_core.Signal<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
+    /** The key used to navigate to the next radio button. */
+    nextKey: _angular_core.Signal<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
+    /** The keydown event manager for the radio group. */
+    keydown: _angular_core.Signal<KeyboardEventManager<KeyboardEvent>>;
+    /** The pointerdown event manager for the radio group. */
+    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[];
+    /** Finds the RadioButtonPattern associated with a pointer event target. */
+    private _getItem;
+}
+
+export { RadioGroupPattern };
+export type { RadioGroupInputs, ToolbarLike };

package/tabs/index.d.ts

@@ -1,11 +1,11 @@
 import * as _angular_core from '@angular/core';
 import { Signal, OnInit, OnDestroy } from '@angular/core';
 import * as _angular_cdk_bidi from '@angular/cdk/bidi';
-import { a as TabPattern, c as TabPanelPattern, e as TabListPattern } from '../tabs.d-Db8oTrMB.js';
+import { TabPattern, TabPanelPattern, TabListPattern } from '../tabs.d.js';
 import * as i1 from '@angular/cdk-experimental/deferred-content';
-import '../pointer-event-manager.d-BqSm9Jh5.js';
-import '../list-selection.d-fbAPr_N_.js';
-import '../expansion.d-Zkcf-XJU.js';
+import '../pointer-event-manager.d.js';
+import '../expansion.d.js';
+import '../list.d.js';
 
 interface HasElement {
     element: Signal<HTMLElement>;

package/{tabs.d-Db8oTrMB.d.ts → tabs.d.d.ts}

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
-import { S as SignalLike, e as ListNavigationItem, f as ListFocusItem, L as ListNavigationInputs, a as ListFocusInputs, b as ListNavigation, d as ListFocus, K as KeyboardEventManager, P as PointerEventManager } from './pointer-event-manager.d-BqSm9Jh5.js';
-import { a as ListSelectionItem, b as ListSelectionInputs, L as ListSelection } from './list-selection.d-fbAPr_N_.js';
-import { E as ExpansionItem, b as ExpansionControl, L as ListExpansionInputs, a as ListExpansion } from './expansion.d-Zkcf-XJU.js';
+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';
 
 /** Represents the required inputs for the label control. */
 interface LabelControlInputs {
@@ -26,7 +26,7 @@ declare class LabelControl {
 }
 
 /** The required inputs to tabs. */
-interface TabInputs extends ListNavigationItem, ListSelectionItem<string>, ListFocusItem, Omit<ExpansionItem, 'expansionId' | 'expandable'> {
+interface TabInputs extends Omit<ListItem<string>, 'searchTerm' | 'index'>, Omit<ExpansionItem, 'expansionId' | 'expandable'> {
     /** The parent tablist that controls the tab. */
     tablist: SignalLike<TabListPattern>;
     /** The remote tabpanel controlled by the tab. */
@@ -39,12 +39,16 @@ declare class TabPattern {
     readonly expansion: ExpansionControl;
     /** A global unique identifier for the tab. */
     readonly id: SignalLike<string>;
+    /** The index of the tab. */
+    readonly index: _angular_core.Signal<number>;
     /** A local unique identifier for the tab. */
     readonly value: SignalLike<string>;
     /** Whether the tab is disabled. */
     readonly disabled: SignalLike<boolean>;
     /** The html element that should receive focus. */
     readonly element: SignalLike<HTMLElement>;
+    /** The text used by the typeahead search. */
+    readonly searchTerm: () => string;
     /** Whether this tab has expandable content. */
     readonly expandable: _angular_core.Signal<boolean>;
     /** The unique identifier used by the expansion behavior. */
@@ -79,26 +83,18 @@ declare class TabPanelPattern {
     /** Whether the tabpanel is hidden. */
     readonly hidden: _angular_core.Signal<boolean>;
     /** The tabindex of this tabpanel. */
-    readonly tabindex: _angular_core.Signal<-1 | 0>;
+    readonly tabindex: _angular_core.Signal<0 | -1>;
     /** The aria-labelledby value for this tabpanel. */
     readonly labelledBy: _angular_core.Signal<string | undefined>;
     constructor(inputs: TabPanelInputs);
 }
-/** The selection operations that the tablist can perform. */
-interface SelectOptions {
-    select?: boolean;
-}
 /** The required inputs for the tablist. */
-type TabListInputs = ListNavigationInputs<TabPattern> & Omit<ListSelectionInputs<TabPattern, string>, 'multi'> & ListFocusInputs<TabPattern> & Omit<ListExpansionInputs, 'multiExpandable' | 'expandedIds' | 'items'>;
+type TabListInputs = Omit<ListInputs<TabPattern, string>, 'multi' | 'typeaheadDelay'> & Omit<ListExpansionInputs, 'multiExpandable' | 'expandedIds' | 'items'>;
 /** Controls the state of a tablist. */
 declare class TabListPattern {
     readonly inputs: TabListInputs;
-    /** Controls navigation for the tablist. */
-    readonly navigation: ListNavigation<TabPattern>;
-    /** Controls selection for the tablist. */
-    readonly selection: ListSelection<TabPattern, string>;
-    /** Controls focus for the tablist. */
-    readonly focusManager: ListFocus<TabPattern>;
+    /** The list behavior for the tablist. */
+    readonly listBehavior: List<TabPattern, string>;
     /** Controls expansion for the tablist. */
     readonly expansionManager: ListExpansion;
     /** Whether the tablist is vertically or horizontally oriented. */
@@ -133,20 +129,9 @@ declare class TabListPattern {
     onKeydown(event: KeyboardEvent): void;
     /** The pointerdown event manager for the tablist. */
     onPointerdown(event: PointerEvent): void;
-    /** Navigates to the first option in the tablist. */
-    first(opts?: SelectOptions): void;
-    /** Navigates to the last option in the tablist. */
-    last(opts?: SelectOptions): void;
-    /** Navigates to the next option in the tablist. */
-    next(opts?: SelectOptions): void;
-    /** Navigates to the previous option in the tablist. */
-    prev(opts?: SelectOptions): void;
-    /** Navigates to the given item in the tablist. */
-    goto(event: PointerEvent, opts?: SelectOptions): void;
-    /** Handles updating selection for the tablist. */
-    private _select;
+    /** Returns the tab item associated with the given pointer event. */
     private _getItem;
 }
 
-export { TabPattern as a, TabPanelPattern as c, TabListPattern as e };
-export type { TabInputs as T, TabPanelInputs as b, TabListInputs as d };
+export { TabListPattern, TabPanelPattern, TabPattern };
+export type { TabInputs, TabListInputs, TabPanelInputs };

package/toolbar/index.d.ts

@@ -0,0 +1,89 @@
+import * as _angular_core from '@angular/core';
+import { Signal, OnInit, OnDestroy } from '@angular/core';
+import * as _angular_cdk_bidi from '@angular/cdk/bidi';
+import { RadioButtonPattern, ToolbarWidgetPattern, ToolbarPattern } from '../toolbar.d.js';
+import '../pointer-event-manager.d.js';
+import '../list.d.js';
+
+/** Interface for a radio button that can be used with a toolbar. Based on radio-button in ui-patterns */
+interface CdkRadioButtonInterface<V> {
+    /** The HTML element associated with the radio button. */
+    element: Signal<HTMLElement>;
+    /** Whether the radio button is disabled. */
+    disabled: Signal<boolean>;
+    pattern: RadioButtonPattern<V>;
+}
+/**
+ * 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> {
+    /** The CdkTabList nested inside of the container. */
+    private readonly _cdkWidgets;
+    /** A signal wrapper for directionality. */
+    textDirection: _angular_core.WritableSignal<_angular_cdk_bidi.Direction>;
+    /** Sorted UIPatterns of the child widgets */
+    items: Signal<(RadioButtonPattern<V> | ToolbarWidgetPattern)[]>;
+    /** Whether the toolbar is vertically or horizontally oriented. */
+    orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    /** Whether disabled items in the group should be skipped when navigating. */
+    skipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the toolbar is disabled. */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether focus should wrap when navigating. */
+    readonly wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The toolbar UIPattern. */
+    pattern: ToolbarPattern<V>;
+    /** Whether the toolbar has received focus yet. */
+    private _hasFocused;
+    onFocus(): void;
+    constructor();
+    register(widget: CdkRadioButtonInterface<V> | CdkToolbarWidget): void;
+    unregister(widget: CdkRadioButtonInterface<V> | CdkToolbarWidget): void;
+    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 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. */
+    protected id: Signal<string>;
+    /** The parent Toolbar UIPattern. */
+    protected parentToolbar: Signal<ToolbarPattern<any>>;
+    /** A reference to the widget element to be focused on navigation. */
+    element: Signal<any>;
+    /** Whether the widget is disabled. */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly hardDisabled: Signal<boolean>;
+    pattern: ToolbarWidgetPattern;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CdkToolbarWidget, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CdkToolbarWidget, "[cdkToolbarWidget]", ["cdkToolbarWidget"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { CdkToolbar, CdkToolbarWidget };