@angular/aria 22.0.0-next.3 → 22.0.0-next.5

package/types/listbox.d.ts

@@ -3,11 +3,13 @@ import * as _angular_core from '@angular/core';
 import { OptionPattern, ListboxPattern } from './_listbox-chunk.js';
 import { ComboboxPopup } from './combobox.js';
 export { Combobox as ɵɵCombobox, ComboboxDialog as ɵɵComboboxDialog, ComboboxInput as ɵɵComboboxInput, ComboboxPopupContainer as ɵɵComboboxPopupContainer } from './combobox.js';
-import './_list-navigation-chunk.js';
+import './_signal-like-chunk.js';
 import './_list-chunk.js';
+import './_list-navigation-chunk.js';
 import './_keyboard-event-manager-chunk.js';
-import './_pointer-event-manager-chunk.js';
+import './_click-event-manager-chunk.js';
 import './_combobox-chunk.js';
+import './_pointer-event-manager-chunk.js';
 import './_deferred-content-chunk.js';
 
 /**
@@ -46,46 +48,43 @@ declare class Listbox<V> {
     /** The Options nested inside of the Listbox. */
     private readonly _options;
     /** A signal wrapper for directionality. */
-    protected textDirection: _angular_core.Signal<_angular_cdk_bidi.Direction>;
+    protected readonly textDirection: _angular_core.Signal<_angular_cdk_bidi.Direction>;
     /** The Option UIPatterns of the child Options. */
-    protected items: _angular_core.Signal<OptionPattern<V>[]>;
+    protected readonly items: _angular_core.Signal<OptionPattern<V>[]>;
     /** Whether the list is vertically or horizontally oriented. */
-    orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
     /** Whether multiple items in the list can be selected at once. */
-    multi: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly multi: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether focus should wrap when navigating. */
-    wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * Whether to allow disabled items to receive focus. When `true`, disabled items are
      * focusable but not interactive. When `false`, disabled items are skipped during navigation.
      */
-    softDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly softDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * The focus strategy used by the list.
      * - `roving`: Focus is moved to the active item using `tabindex`.
      * - `activedescendant`: Focus remains on the listbox container, and `aria-activedescendant` is used to indicate the active item.
      */
-    focusMode: _angular_core.InputSignal<"roving" | "activedescendant">;
+    readonly focusMode: _angular_core.InputSignal<"roving" | "activedescendant">;
     /**
      * The selection strategy used by the list.
      * - `follow`: The focused item is automatically selected.
      * - `explicit`: Items are selected explicitly by the user (e.g., via click or spacebar).
      */
-    selectionMode: _angular_core.InputSignal<"follow" | "explicit">;
+    readonly selectionMode: _angular_core.InputSignal<"follow" | "explicit">;
     /** The amount of time before the typeahead search is reset. */
-    typeaheadDelay: _angular_core.InputSignal<number>;
+    readonly typeaheadDelay: _angular_core.InputSignal<number>;
     /** Whether the listbox is disabled. */
-    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the listbox is readonly. */
-    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** The values of the currently selected items. */
-    value: _angular_core.ModelSignal<V[]>;
+    readonly value: _angular_core.ModelSignal<V[]>;
     /** The Listbox UIPattern. */
     readonly _pattern: ListboxPattern<V>;
-    /** Whether the listbox has received focus yet. */
-    private _hasFocused;
     constructor();
-    _onFocus(): void;
     scrollActiveItemIntoView(options?: ScrollIntoViewOptions): void;
     /** Navigates to the first item in the listbox. */
     gotoFirst(): void;
@@ -117,21 +116,21 @@ declare class Option<V> {
     /** A reference to the host element. */
     readonly element: HTMLElement;
     /** Whether the option is currently active (focused). */
-    active: _angular_core.Signal<boolean>;
+    readonly active: _angular_core.Signal<boolean>;
     /** The parent Listbox. */
     private readonly _listbox;
     /** A unique identifier for the option. */
     readonly id: _angular_core.InputSignal<string>;
     /** The text used by the typeahead search. */
-    protected searchTerm: _angular_core.Signal<string>;
+    protected readonly searchTerm: _angular_core.Signal<string>;
     /** The parent Listbox UIPattern. */
     private readonly _listboxPattern;
     /** The value of the option. */
-    value: _angular_core.InputSignal<V>;
+    readonly value: _angular_core.InputSignal<V>;
     /** Whether an item is disabled. */
-    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** The text used by the typeahead search. */
-    label: _angular_core.InputSignal<string | undefined>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
     /** Whether the option is selected. */
     readonly selected: _angular_core.Signal<boolean | undefined>;
     /** The Option UIPattern. */

package/types/menu-testing.d.ts

@@ -0,0 +1,50 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate, TestElement } from '@angular/cdk/testing';
+
+/** Filters for locating a `MenuHarness`. */
+interface MenuHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose trigger text matches the given value. */
+    triggerText?: string | RegExp;
+}
+/** Filters for locating a `MenuItemHarness`. */
+interface MenuItemHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose text matches the given value. */
+    text?: string | RegExp;
+    /** Only find instances whose disabled state matches the given value. */
+    disabled?: boolean;
+    /** Only find instances whose expanded state matches the given value. */
+    expanded?: boolean;
+}
+
+/** Harness for interacting with a standard ngMenuItem in tests. */
+declare class MenuItemHarness extends ComponentHarness {
+    static hostSelector: string;
+    static with(options?: MenuItemHarnessFilters): HarnessPredicate<MenuItemHarness>;
+    /** Gets the text content of the menu item. */
+    getText(): Promise<string>;
+    /** Whether the menu item is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Whether the menu item is expanded (contains an open submenu). */
+    isExpanded(): Promise<boolean>;
+    /** Clicks the menu item to trigger its action or toggle its submenu. */
+    click(): Promise<void>;
+    /** Resolves the nested submenu panel associated with this menu item, if any exists. */
+    getSubmenu(): Promise<MenuHarness | null>;
+}
+/** Harness for interacting with a standard ngMenu or ngMenuBar in tests. */
+declare class MenuHarness extends ComponentHarness {
+    static hostSelector: string;
+    static with(options?: MenuHarnessFilters): HarnessPredicate<MenuHarness>;
+    /** Resolves the trigger associated with this menu container via aria-controls inversion. */
+    _getTrigger(): Promise<TestElement | null>;
+    /** Checks whether the menu container is visible. */
+    isOpen(): Promise<boolean>;
+    /** Opens the menu if it is currently closed. */
+    open(): Promise<void>;
+    /** Closes the menu if it is currently open. */
+    close(): Promise<void>;
+    /** Queries all menu items inside this menu container. */
+    getItems(filters?: MenuItemHarnessFilters): Promise<MenuItemHarness[]>;
+}
+
+export { MenuHarness, MenuItemHarness };
+export type { MenuHarnessFilters, MenuItemHarnessFilters };

package/types/menu.d.ts

@@ -3,9 +3,10 @@ import { Signal } from '@angular/core';
 import * as _angular_cdk_bidi from '@angular/cdk/bidi';
 import { MenuBarPattern, MenuItemPattern, MenuPattern, MenuTriggerPattern } from './_menu-chunk.js';
 import { DeferredContentAware, DeferredContent } from './_deferred-content-chunk.js';
-import { SignalLike } from './_list-navigation-chunk.js';
+import { SignalLike } from './_signal-like-chunk.js';
 import './_keyboard-event-manager-chunk.js';
 import './_list-chunk.js';
+import './_list-navigation-chunk.js';
 
 /**
  * A menu bar of menu items.
@@ -225,7 +226,7 @@ declare class MenuTrigger<V> {
     /** The directionality (LTR / RTL) context for the application (or a subtree of it). */
     readonly textDirection: _angular_core.WritableSignal<_angular_cdk_bidi.Direction>;
     /** The menu associated with the trigger. */
-    menu: _angular_core.InputSignal<Menu<V> | undefined>;
+    readonly menu: _angular_core.InputSignal<Menu<V> | undefined>;
     /** Whether the menu is expanded. */
     readonly expanded: _angular_core.Signal<boolean>;
     /** Whether the menu trigger has a popup. */
@@ -235,7 +236,7 @@ declare class MenuTrigger<V> {
     /** Whether the menu trigger is soft disabled. */
     readonly softDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** The menu trigger ui pattern instance. */
-    _pattern: MenuTriggerPattern<V>;
+    readonly _pattern: MenuTriggerPattern<V>;
     constructor();
     /** Opens the menu focusing on the first menu item. */
     open(): void;

package/types/private.d.ts

@@ -2,8 +2,8 @@ import { ComboboxPattern, ComboboxListboxControls, ComboboxTreeControls } from '
 export { ComboboxDialogPattern, ComboboxInputs } from './_combobox-chunk.js';
 import { ListboxInputs, OptionPattern, ListboxPattern } from './_listbox-chunk.js';
 export { OptionInputs } from './_listbox-chunk.js';
-import { SignalLike } from './_list-navigation-chunk.js';
-export { WritableSignalLike, computed, convertGetterSetterToWritableSignalLike, linkedSignal, signal } from './_list-navigation-chunk.js';
+import { SignalLike } from './_signal-like-chunk.js';
+export { WritableSignalLike, computed, convertGetterSetterToWritableSignalLike, linkedSignal, signal } from './_signal-like-chunk.js';
 export { MenuBarInputs, MenuBarPattern, MenuInputs, MenuItemInputs, MenuItemPattern, MenuPattern, MenuTriggerInputs, MenuTriggerPattern } from './_menu-chunk.js';
 export { TabInputs, TabListInputs, TabListPattern, TabPanelInputs, TabPanelPattern, TabPattern } from './_tabs-chunk.js';
 export { ToolbarInputs, ToolbarPattern, ToolbarWidgetGroupInputs, ToolbarWidgetGroupPattern, ToolbarWidgetInputs, ToolbarWidgetPattern } from './_toolbar-chunk.js';
@@ -12,10 +12,13 @@ import { TreeInputs, TreeItemPattern, TreePattern } from './_tree-chunk.js';
 export { TreeItemInputs } from './_tree-chunk.js';
 export { GridCellInputs, GridCellPattern, GridCellWidgetInputs, GridCellWidgetPattern, GridInputs, GridPattern, GridRowInputs, GridRowPattern } from './_grid-chunk.js';
 export { DeferredContent, DeferredContentAware } from './_deferred-content-chunk.js';
+export { HasElement, sortDirectives } from './_element-chunk.js';
 export { untracked } from '@angular/core/primitives/signals';
 import './_keyboard-event-manager-chunk.js';
 import './_pointer-event-manager-chunk.js';
 import './_list-chunk.js';
+import './_list-navigation-chunk.js';
+import './_click-event-manager-chunk.js';
 import './_expansion-chunk.js';
 import '@angular/core';
 
@@ -26,13 +29,13 @@ type ComboboxListboxInputs<V> = ListboxInputs<V> & {
 declare class ComboboxListboxPattern<V> extends ListboxPattern<V> implements ComboboxListboxControls<OptionPattern<V>, V> {
     readonly inputs: ComboboxListboxInputs<V>;
     /** A unique identifier for the popup. */
-    id: SignalLike<string>;
+    readonly id: SignalLike<string>;
     /** The ARIA role for the listbox. */
-    role: SignalLike<"listbox">;
+    readonly role: SignalLike<"listbox">;
     /** The id of the active (focused) item in the listbox. */
-    activeId: SignalLike<string | undefined>;
+    readonly activeId: SignalLike<string | undefined>;
     /** The list of options in the listbox. */
-    items: SignalLike<OptionPattern<V>[]>;
+    readonly items: SignalLike<OptionPattern<V>[]>;
     /** The tab index for the listbox. Always -1 because the combobox handles focus. */
     tabIndex: SignalLike<-1 | 0>;
     /** Whether multiple items in the list can be selected at once. */
@@ -41,37 +44,37 @@ declare class ComboboxListboxPattern<V> extends ListboxPattern<V> implements Com
     /** Noop. The combobox handles keydown events. */
     onKeydown(_: KeyboardEvent): void;
     /** Noop. The combobox handles pointerdown events. */
-    onPointerdown(_: PointerEvent): void;
+    onClick(_: PointerEvent): void;
     /** Noop. The combobox controls the open state. */
     setDefaultState(): void;
     /** Navigates to the specified item in the listbox. */
-    focus: (item: OptionPattern<V>, opts?: {
+    readonly focus: (item: OptionPattern<V>, opts?: {
         focusElement?: boolean;
     }) => void;
     /** Navigates to the previous focusable item in the listbox. */
-    getActiveItem: () => OptionPattern<V> | undefined;
+    readonly getActiveItem: () => OptionPattern<V> | undefined;
     /** Navigates to the next focusable item in the listbox. */
-    next: () => void;
+    readonly next: () => void;
     /** Navigates to the previous focusable item in the listbox. */
-    prev: () => void;
+    readonly prev: () => void;
     /** Navigates to the last focusable item in the listbox. */
-    last: () => void;
+    readonly last: () => void;
     /** Navigates to the first focusable item in the listbox. */
-    first: () => void;
+    readonly first: () => void;
     /** Unfocuses the currently focused item in the listbox. */
-    unfocus: () => void;
+    readonly unfocus: () => void;
     /** Selects the specified item in the listbox. */
-    select: (item?: OptionPattern<V>) => void;
+    readonly select: (item?: OptionPattern<V>) => void;
     /** Toggles the selection state of the given item in the listbox. */
-    toggle: (item?: OptionPattern<V>) => void;
+    readonly toggle: (item?: OptionPattern<V>) => void;
     /** Clears the selection in the listbox. */
-    clearSelection: () => void;
+    readonly clearSelection: () => void;
     /** Retrieves the OptionPattern associated with a pointer event. */
-    getItem: (e: PointerEvent) => OptionPattern<V> | undefined;
+    readonly getItem: (e: PointerEvent) => OptionPattern<V> | undefined;
     /** Retrieves the currently selected items in the listbox. */
-    getSelectedItems: () => OptionPattern<V>[];
+    readonly getSelectedItems: () => OptionPattern<V>[];
     /** Sets the value of the combobox listbox. */
-    setValue: (value: V | undefined) => void;
+    readonly setValue: (value: V | undefined) => void;
 }
 
 type ComboboxTreeInputs<V> = TreeInputs<V> & {
@@ -81,61 +84,61 @@ type ComboboxTreeInputs<V> = TreeInputs<V> & {
 declare class ComboboxTreePattern<V> extends TreePattern<V> implements ComboboxTreeControls<TreeItemPattern<V>, V> {
     readonly inputs: ComboboxTreeInputs<V>;
     /** Toggles to expand or collapse a tree item. */
-    toggleExpansion: (item?: TreeItemPattern<V>) => void;
+    readonly toggleExpansion: (item?: TreeItemPattern<V>) => void;
     /** Whether the currently focused item is collapsible. */
-    isItemCollapsible: () => boolean;
+    readonly isItemCollapsible: () => boolean;
     /** The ARIA role for the tree. */
-    role: () => "tree";
-    activeId: SignalLike<string | undefined>;
+    readonly role: () => "tree";
+    readonly activeId: SignalLike<string | undefined>;
     /** Returns the currently active (focused) item in the tree. */
-    getActiveItem: () => TreeItemPattern<V> | undefined;
+    readonly getActiveItem: () => TreeItemPattern<V> | undefined;
     /** The list of items in the tree. */
     items: SignalLike<TreeItemPattern<V>[]>;
     /** The tab index for the tree. Always -1 because the combobox handles focus. */
-    tabIndex: SignalLike<-1 | 0>;
+    readonly 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 handles click events. */
+    onClick(_: PointerEvent): void;
     /** Noop. The combobox controls the open state. */
     setDefaultState(): void;
     /** Navigates to the specified item in the tree. */
-    focus: (item: TreeItemPattern<V>) => void;
+    readonly focus: (item: TreeItemPattern<V>) => void;
     /** Navigates to the next focusable item in the tree. */
-    next: () => void;
+    readonly next: () => void;
     /** Navigates to the previous focusable item in the tree. */
-    prev: () => void;
+    readonly prev: () => void;
     /** Navigates to the last focusable item in the tree. */
-    last: () => void;
+    readonly last: () => void;
     /** Navigates to the first focusable item in the tree. */
-    first: () => void;
+    readonly first: () => void;
     /** Unfocuses the currently focused item in the tree. */
-    unfocus: () => void;
+    readonly unfocus: () => void;
     /** Selects the specified item in the tree or the current active item if not provided. */
-    select: (item?: TreeItemPattern<V>) => void;
+    readonly select: (item?: TreeItemPattern<V>) => void;
     /** Toggles the selection state of the given item in the tree or the current active item if not provided. */
-    toggle: (item?: TreeItemPattern<V>) => void;
+    readonly toggle: (item?: TreeItemPattern<V>) => void;
     /** Clears the selection in the tree. */
-    clearSelection: () => void;
+    readonly clearSelection: () => void;
     /** Retrieves the TreeItemPattern associated with a pointer event. */
-    getItem: (e: PointerEvent) => TreeItemPattern<V> | undefined;
+    readonly getItem: (e: PointerEvent) => TreeItemPattern<V> | undefined;
     /** Retrieves the currently selected items in the tree */
-    getSelectedItems: () => TreeItemPattern<V>[];
+    readonly getSelectedItems: () => TreeItemPattern<V>[];
     /** Sets the value of the combobox tree. */
-    setValue: (value: V | undefined) => void;
+    readonly setValue: (value: V | undefined) => void;
     /** Expands the currently focused item if it is expandable, or navigates to the first child. */
-    expandItem: () => void;
+    readonly expandItem: () => void;
     /** Collapses the currently focused item if it is expandable, or navigates to the parent. */
-    collapseItem: () => void;
+    readonly 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;
+    readonly expandAll: () => void;
     /** Collapses all of the tree items. */
-    collapseAll: () => void;
+    readonly collapseAll: () => void;
     /** Whether the currently active item is selectable. */
-    isItemSelectable: (item?: TreeItemPattern<V> | undefined) => boolean;
+    readonly isItemSelectable: (item?: TreeItemPattern<V> | undefined) => boolean;
 }
 
 export { ComboboxListboxControls, ComboboxListboxPattern, ComboboxPattern, ComboboxTreeControls, ComboboxTreePattern, ListboxInputs, ListboxPattern, OptionPattern, SignalLike, TreeInputs, TreeItemPattern, TreePattern };

package/types/tabs-testing.d.ts

@@ -0,0 +1,57 @@
+import { BaseHarnessFilters, ContentContainerComponentHarness, HarnessPredicate, HarnessLoader, ComponentHarness } from '@angular/cdk/testing';
+
+/** A set of criteria that can be used to filter a list of `TabsHarness` instances. */
+interface TabsHarnessFilters extends BaseHarnessFilters {
+}
+/** A set of criteria that can be used to filter a list of `TabHarness` instances. */
+interface TabHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose title matches the given value. */
+    title?: string | RegExp;
+    /** Only find instances that are selected. */
+    selected?: boolean;
+    /** Only find instances that are disabled. */
+    disabled?: boolean;
+}
+
+/** Harness for interacting with an Aria tab in tests. */
+declare class TabHarness extends ContentContainerComponentHarness {
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `TabHarness`
+     * that meets certain criteria.
+     * @param options Options for filtering which tab instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: TabHarnessFilters): HarnessPredicate<TabHarness>;
+    /** Gets the tab's title text. */
+    getTitle(): Promise<string>;
+    /** Clicks the tab to select it. */
+    select(): Promise<void>;
+    /** Gets whether the tab is selected. */
+    isSelected(): Promise<boolean>;
+    /** Gets whether the tab is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Gets whether the tab is active. */
+    isActive(): Promise<boolean>;
+    protected getRootHarnessLoader(): Promise<HarnessLoader>;
+}
+/** Harness for interacting with an Aria tabs container in tests. */
+declare class TabsHarness extends ComponentHarness {
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `TabsHarness`
+     * that meets certain criteria.
+     * @param options Options for filtering which tabs instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: TabsHarnessFilters): HarnessPredicate<TabsHarness>;
+    /** Gets all tabs inside the tabs container. */
+    getTabs(filters?: TabHarnessFilters): Promise<TabHarness[]>;
+    /** Gets the currently selected tab. */
+    getSelectedTab(): Promise<TabHarness | null>;
+    /** Selects a tab matching the given filters. */
+    selectTab(filters?: TabHarnessFilters): Promise<void>;
+}
+
+export { TabHarness, TabsHarness };
+export type { TabHarnessFilters, TabsHarnessFilters };

package/types/tabs.d.ts

@@ -2,15 +2,13 @@ import * as _angular_core from '@angular/core';
 import { OnInit, OnDestroy } from '@angular/core';
 import * as _angular_cdk_bidi from '@angular/cdk/bidi';
 import { TabPattern, TabListPattern, TabPanelPattern } from './_tabs-chunk.js';
+import { HasElement } from './_element-chunk.js';
 import { DeferredContentAware, DeferredContent } from './_deferred-content-chunk.js';
 import './_keyboard-event-manager-chunk.js';
-import './_list-navigation-chunk.js';
-import './_pointer-event-manager-chunk.js';
+import './_signal-like-chunk.js';
+import './_click-event-manager-chunk.js';
 import './_expansion-chunk.js';
-
-interface HasElement {
-    element: HTMLElement;
-}
+import './_list-navigation-chunk.js';
 
 /**
  * A selectable tab in a TabList.
@@ -119,10 +117,7 @@ declare class TabList implements OnInit, OnDestroy {
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** The TabList UIPattern. */
     readonly _pattern: TabListPattern;
-    /** Whether the tree has received focus yet. */
-    private _hasFocused;
     constructor();
-    _onFocus(): void;
     ngOnInit(): void;
     ngOnDestroy(): void;
     _register(child: Tab): void;

package/types/toolbar-testing.d.ts

@@ -0,0 +1,72 @@
+import { BaseHarnessFilters, ContentContainerComponentHarness, HarnessPredicate, ComponentHarness } from '@angular/cdk/testing';
+
+/** A set of criteria that can be used to filter a list of Aria toolbar instances. */
+interface ToolbarHarnessFilters extends BaseHarnessFilters {
+}
+/** A set of criteria that can be used to filter a list of Aria toolbar widget group instances. */
+interface ToolbarWidgetGroupHarnessFilters extends BaseHarnessFilters {
+}
+/** A set of criteria that can be used to filter a list of Aria toolbar widgets. */
+interface ToolbarWidgetHarnessFilters extends BaseHarnessFilters {
+    /** Text that the widget should match. */
+    text?: string | RegExp;
+    /** Active state that the widget should match. */
+    active?: boolean;
+}
+
+/** Harness for interacting with an Aria toolbar widget in tests. */
+declare class ToolbarWidgetHarness extends ContentContainerComponentHarness<string> {
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `ToolbarWidgetHarness`
+     * that meets certain criteria.
+     * @param options Options for filtering which dialog instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: ToolbarWidgetHarnessFilters): HarnessPredicate<ToolbarWidgetHarness>;
+    /** Gets the widget's text. */
+    getText(): Promise<string>;
+    /** Clicks the widget. */
+    click(): Promise<void>;
+    /** Gets whether the widget is active. */
+    isActive(): Promise<boolean>;
+    /** Gets whether the widget is disabled. */
+    isDisabled(): Promise<boolean>;
+}
+
+/** Harness for interacting with an Aria toolbar widget group in tests. */
+declare class ToolbarWidgetGroupHarness extends ComponentHarness {
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `ToolbarWidgetGroupHarness`
+     * that meets certain criteria.
+     * @param options Options for filtering which dialog instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: ToolbarWidgetGroupHarnessFilters): HarnessPredicate<ToolbarWidgetGroupHarness>;
+    /** Gets all widgets in the group. */
+    getWidgets(filters?: ToolbarWidgetHarnessFilters): Promise<ToolbarWidgetHarness[]>;
+}
+
+/** Harness for interacting with an Aria toolbar in tests. */
+declare class ToolbarHarness extends ComponentHarness {
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `ToolbarHarness`
+     * that meets certain criteria.
+     * @param options Options for filtering which dialog instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: ToolbarHarnessFilters): HarnessPredicate<ToolbarHarness>;
+    /** Gets all widgets in the toolbar. */
+    getWidgets(filters?: ToolbarWidgetHarnessFilters): Promise<ToolbarWidgetHarness[]>;
+    /** Gets all widget groups in the toolbar. */
+    getWidgetGroups(filters?: ToolbarWidgetGroupHarnessFilters): Promise<ToolbarWidgetGroupHarness[]>;
+    /** Gets whether the toolbar is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Gets the orientation of the toolbar. */
+    getOrientation(): Promise<'vertical' | 'horizontal'>;
+}
+
+export { ToolbarHarness, ToolbarWidgetGroupHarness, ToolbarWidgetHarness };
+export type { ToolbarHarnessFilters, ToolbarWidgetGroupHarnessFilters, ToolbarWidgetHarnessFilters };

package/types/toolbar.d.ts

@@ -2,8 +2,9 @@ import * as _angular_core from '@angular/core';
 import { OnInit, OnDestroy } from '@angular/core';
 import * as _angular_cdk_bidi from '@angular/cdk/bidi';
 import { ToolbarWidgetGroupPattern, ToolbarWidgetPattern, ToolbarPattern } from './_toolbar-chunk.js';
-import './_list-navigation-chunk.js';
+import './_signal-like-chunk.js';
 import './_list-chunk.js';
+import './_list-navigation-chunk.js';
 
 /**
  * A directive that groups toolbar widgets, used for more complex widgets like radio groups
@@ -124,7 +125,7 @@ declare class Toolbar<V> {
      * Whether to allow disabled items to receive focus. When `true`, disabled items are
      * focusable but not interactive. When `false`, disabled items are skipped during navigation.
      */
-    softDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly softDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the toolbar is disabled. */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether focus should wrap when navigating. */
@@ -133,10 +134,7 @@ declare class Toolbar<V> {
     readonly value: _angular_core.ModelSignal<V[]>;
     /** The toolbar UIPattern. */
     readonly _pattern: ToolbarPattern<V>;
-    /** Whether the toolbar has received focus yet. */
-    private _hasBeenFocused;
     constructor();
-    _onFocus(): void;
     _register(widget: ToolbarWidget<V>): void;
     _unregister(widget: ToolbarWidget<V>): void;
     /** Finds the toolbar item associated with a given element. */

package/types/tree-testing.d.ts

@@ -0,0 +1,75 @@
+import { BaseHarnessFilters, ContentContainerComponentHarness, HarnessPredicate, ComponentHarness } from '@angular/cdk/testing';
+
+/** A set of criteria that can be used to filter a list of tree harness instances */
+interface TreeHarnessFilters extends BaseHarnessFilters {
+}
+/** A set of criteria that can be used to filter a list of tree item harness instances. */
+interface TreeItemHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose text matches the given value. */
+    text?: string | RegExp;
+    /** Only find instances whose disabled state matches the given value. */
+    disabled?: boolean;
+    /** Only find instances whose expansion state matches the given value. */
+    expanded?: boolean;
+    /** Only find instances whose selection state matches the given value. */
+    selected?: boolean;
+    /** Only find instances whose level matches the given value. */
+    level?: number;
+}
+
+/** Harness for interacting with an Aria tree item. */
+declare class TreeItemHarness extends ContentContainerComponentHarness<string> {
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a tree item with specific attributes.
+     * @param options Options for narrowing the search
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: TreeItemHarnessFilters): HarnessPredicate<TreeItemHarness>;
+    /** Whether the tree item is expanded. */
+    isExpanded(): Promise<boolean>;
+    /** Whether the tree item is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Whether the tree item is selected. */
+    isSelected(): Promise<boolean>;
+    /** Gets the level of the tree item. Note that this gets the aria-level and is 1 indexed. */
+    getLevel(): Promise<number>;
+    /** Gets the tree item's text. */
+    getText(): Promise<string>;
+    /** Clicks the tree item. */
+    click(): Promise<void>;
+    private _getHostAttribute;
+}
+
+interface TextTree {
+    text?: string;
+    children?: TextTree[];
+}
+/** Harness for interacting with an Aria tree in tests. */
+declare class TreeHarness extends ComponentHarness {
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a tree with specific attributes.
+     * @param options Options for narrowing the search
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: TreeHarnessFilters): HarnessPredicate<TreeHarness>;
+    /** Gets all of the items in the tree. */
+    getItems(filter?: TreeItemHarnessFilters): Promise<TreeItemHarness[]>;
+    /**
+     * Gets an object representation for the visible tree structure
+     * If an item is under an unexpanded item it will not be included.
+     */
+    getTreeStructure(): Promise<TextTree>;
+    /**
+     * Recursively collect the structured text of the tree items.
+     * @param items A list of tree items
+     * @param level The level of items that are being accounted for during this iteration
+     * @param parentExpanded Whether the parent of the first item in param items is expanded
+     */
+    private _getTreeStructure;
+    private _addChildToItem;
+}
+
+export { TreeHarness, TreeItemHarness };
+export type { TextTree, TreeHarnessFilters, TreeItemHarnessFilters };