@angular/aria 21.0.0-next.9 → 21.0.0-rc.0

package/types/{ui-patterns.d.ts → private.d.ts}

@@ -1,107 +1,7 @@
 import * as _angular_core from '@angular/core';
-
-/**
- * Options that are applicable to all event handlers.
- *
- * This library has not yet had a need for stopPropagationImmediate.
- */
-interface EventHandlerOptions {
-    stopPropagation: boolean;
-    preventDefault: boolean;
-}
-/** A basic event handler. */
-type EventHandler<T extends Event> = (event: T) => void;
-/** A function that determines whether an event is to be handled. */
-type EventMatcher<T extends Event> = (event: T) => boolean;
-/** A config that specifies how to handle a particular event. */
-interface EventHandlerConfig<T extends Event> extends EventHandlerOptions {
-    matcher: EventMatcher<T>;
-    handler: EventHandler<T>;
-}
-/** Bit flag representation of the possible modifier keys that can be present on an event. */
-declare enum Modifier {
-    None = 0,
-    Ctrl = 1,
-    Shift = 2,
-    Alt = 4,
-    Meta = 8,
-    Any = "Any"
-}
-type ModifierInputs = Modifier | Modifier[];
-/**
- * Abstract base class for all event managers.
- *
- * Event managers are designed to normalize how event handlers are authored and create a safety net
- * for common event handling gotchas like remembering to call preventDefault or stopPropagation.
- */
-declare abstract class EventManager<T extends Event> {
-    protected configs: EventHandlerConfig<T>[];
-    abstract options: EventHandlerOptions;
-    /** Runs the handlers that match with the given event. */
-    handle(event: T): void;
-    /** Configures the event manager to handle specific events. (See subclasses for more). */
-    abstract on(...args: [...unknown[]]): this;
-}
-
-type SignalLike<T> = () => T;
-interface WritableSignalLike<T> extends SignalLike<T> {
-    set(value: T): void;
-    update(updateFn: (value: T) => T): void;
-}
-/** Converts a getter setter style signal to a WritableSignalLike. */
-declare function convertGetterSetterToWritableSignalLike<T>(getter: () => T, setter: (v: T) => void): WritableSignalLike<T>;
-
-/**
- * Used to represent a keycode.
- *
- * This is used to match whether an events keycode should be handled. The ability to match using a
- * string, SignalLike, or Regexp gives us more flexibility when authoring event handlers.
- */
-type KeyCode = string | SignalLike<string> | RegExp;
-/**
- * An event manager that is specialized for handling keyboard events. By default this manager stops
- * propagation and prevents default on all events it handles.
- */
-declare class KeyboardEventManager<T extends KeyboardEvent> extends EventManager<T> {
-    options: EventHandlerOptions;
-    /** Configures this event manager to handle events with a specific key and no modifiers. */
-    on(key: KeyCode, handler: EventHandler<T>): this;
-    /**  Configures this event manager to handle events with a specific modifer and key combination. */
-    on(modifiers: ModifierInputs, key: KeyCode, handler: EventHandler<T>): this;
-    private _normalizeInputs;
-    private _isMatch;
-}
-
-/**
- * The different mouse buttons that may appear on a pointer event.
- */
-declare enum MouseButton {
-    Main = 0,
-    Auxiliary = 1,
-    Secondary = 2
-}
-/** An event manager that is specialized for handling pointer events. */
-declare class PointerEventManager<T extends PointerEvent> extends EventManager<T> {
-    options: EventHandlerOptions;
-    /**
-     * Configures this event manager to handle events with a specific modifer and mouse button
-     * combination.
-     */
-    on(button: MouseButton, modifiers: ModifierInputs, handler: EventHandler<T>): this;
-    /**
-     * Configures this event manager to handle events with a specific mouse button and no modifiers.
-     */
-    on(modifiers: ModifierInputs, handler: EventHandler<T>): this;
-    /**
-     * Configures this event manager to handle events with the main mouse button and no modifiers.
-     *
-     * @param handler The handler function
-     * @param options Options for whether to stop propagation or prevent default.
-     */
-    on(handler: EventHandler<T>): this;
-    private _normalizeInputs;
-    _isMatch(event: PointerEvent, button: MouseButton, modifiers: ModifierInputs): boolean;
-}
+import { Signal } from '@angular/core';
+import { SignalLike, WritableSignalLike, KeyboardEventManager, PointerEventManager } from './_grid-chunk.js';
+export { GridCellInputs, GridCellPattern, GridCellWidgetInputs, GridCellWidgetPattern, GridInputs, GridPattern, GridRowInputs, GridRowPattern, convertGetterSetterToWritableSignalLike } from './_grid-chunk.js';
 
 /** Represents an item in a collection, such as a listbox option, than may receive focus. */
 interface ListFocusItem {
@@ -147,7 +47,9 @@ declare class ListFocus<T extends ListFocusItem> {
     /** Returns the tabindex for the given item. */
     getItemTabindex(item: T): -1 | 0;
     /** Moves focus to the given item if it is focusable. */
-    focus(item: T): boolean;
+    focus(item: T, opts?: {
+        focusElement?: boolean;
+    }): boolean;
     /** Returns true if the given item can be navigated to. */
     isFocusable(item: T): boolean;
 }
@@ -173,19 +75,29 @@ declare class ListNavigation<T extends ListNavigationItem> {
         focusManager: ListFocus<T>;
     });
     /** Navigates to the given item. */
-    goto(item?: T): boolean;
+    goto(item?: T, opts?: {
+        focusElement?: boolean;
+    }): boolean;
     /** Navigates to the next item in the list. */
-    next(): boolean;
+    next(opts?: {
+        focusElement?: boolean;
+    }): boolean;
     /** Peeks the next item in the list. */
     peekNext(): T | undefined;
     /** Navigates to the previous item in the list. */
-    prev(): boolean;
+    prev(opts?: {
+        focusElement?: boolean;
+    }): boolean;
     /** Peeks the previous item in the list. */
     peekPrev(): T | undefined;
     /** Navigates to the first item in the list. */
-    first(): boolean;
+    first(opts?: {
+        focusElement?: boolean;
+    }): boolean;
     /** Navigates to the last item in the list. */
-    last(): boolean;
+    last(opts?: {
+        focusElement?: boolean;
+    }): boolean;
     /** Advances to the next or previous focusable item in the list based on the given delta. */
     private _advance;
     /** Peeks the next or previous focusable item in the list based on the given delta. */
@@ -196,6 +108,8 @@ declare class ListNavigation<T extends ListNavigationItem> {
 interface ListSelectionItem<V> extends ListFocusItem {
     /** The value of the item. */
     value: SignalLike<V>;
+    /** Whether the item is selectable. */
+    selectable: SignalLike<boolean>;
 }
 /** Represents the required inputs for a collection that contains selectable items. */
 interface ListSelectionInputs<T extends ListSelectionItem<V>, V> extends ListFocusInputs<T> {
@@ -299,13 +213,14 @@ declare class ListTypeahead<T extends ListTypeaheadItem> {
     private _getItem;
 }
 
-/** The selection operations that the list can perform. */
-interface SelectOptions$1 {
+/** The operations that the list can perform after navigation. */
+interface NavOptions {
     toggle?: boolean;
     select?: boolean;
     selectOne?: boolean;
     selectRange?: boolean;
     anchor?: boolean;
+    focusElement?: boolean;
 }
 /** Represents an item in the list. */
 type ListItem<V> = ListTypeaheadItem & ListNavigationItem & ListSelectionItem<V> & ListFocusItem;
@@ -349,21 +264,21 @@ declare class List<T extends ListItem<V>, V> {
     /** Returns the tabindex for the given item. */
     getItemTabindex(item: T): 0 | -1;
     /** Navigates to the first option in the list. */
-    first(opts?: SelectOptions$1): void;
+    first(opts?: NavOptions): void;
     /** Navigates to the last option in the list. */
-    last(opts?: SelectOptions$1): void;
+    last(opts?: NavOptions): void;
     /** Navigates to the next option in the list. */
-    next(opts?: SelectOptions$1): void;
+    next(opts?: NavOptions): void;
     /** Navigates to the previous option in the list. */
-    prev(opts?: SelectOptions$1): void;
+    prev(opts?: NavOptions): void;
     /** Navigates to the given item in the list. */
-    goto(item: T, opts?: SelectOptions$1): void;
+    goto(item: T, opts?: NavOptions): void;
     /** Removes focus from the list. */
     unfocus(): void;
     /** Marks the given index as the potential start of a range selection. */
     anchor(index: number): void;
     /** Handles typeahead search navigation for the list. */
-    search(char: string, opts?: SelectOptions$1): void;
+    search(char: string, opts?: NavOptions): void;
     /** Checks if the list is currently typing for typeahead search. */
     isTyping(): boolean;
     /** Selects the currently active item in the list. */
@@ -383,7 +298,7 @@ declare class List<T extends ListItem<V>, V> {
     /** Checks if the given item is able to receive focus. */
     isFocusable(item: T): boolean;
     /** Handles updating selection for the list. */
-    updateSelection(opts?: SelectOptions$1): void;
+    updateSelection(opts?: NavOptions): void;
     /**
      * Safely performs a navigation operation.
      *
@@ -410,6 +325,12 @@ interface ComboboxInputs<T extends ListItem<V>, V> {
     inputValue?: WritableSignalLike<string>;
     /** The value of the first matching item in the popup. */
     firstMatch: SignalLike<V | undefined>;
+    /** Whether the combobox is disabled. */
+    disabled: SignalLike<boolean>;
+    /** Whether the combobox is read-only. */
+    readonly: SignalLike<boolean>;
+    /** Whether the combobox is in a right-to-left context. */
+    textDirection: SignalLike<'rtl' | 'ltr'>;
 }
 /** An interface that allows combobox popups to expose the necessary controls for the combobox. */
 interface ComboboxListboxControls<T extends ListItem<V>, V> {
@@ -472,15 +393,17 @@ declare class ComboboxPattern<T extends ListItem<V>, V> {
     /** Whether the combobox is focused. */
     isFocused: _angular_core.WritableSignal<boolean>;
     /** The key used to navigate to the previous item in the list. */
-    expandKey: _angular_core.Signal<string>;
+    expandKey: _angular_core.Signal<"ArrowLeft" | "ArrowRight">;
     /** The key used to navigate to the next item in the list. */
-    collapseKey: _angular_core.Signal<string>;
+    collapseKey: _angular_core.Signal<"ArrowLeft" | "ArrowRight">;
     /** The ID of the popup associated with the combobox. */
     popupId: _angular_core.Signal<string | null>;
     /** The autocomplete behavior of the combobox. */
     autocomplete: _angular_core.Signal<"both" | "list">;
     /** The ARIA role of the popup associated with the combobox. */
     hasPopup: _angular_core.Signal<"listbox" | "tree" | "grid" | null>;
+    /** Whether the combobox is interactive. */
+    isInteractive: _angular_core.Signal<boolean>;
     /** The keydown event manager for the combobox. */
     keydown: _angular_core.Signal<KeyboardEventManager<KeyboardEvent>>;
     /** The pointerup event manager for the combobox. */
@@ -492,11 +415,15 @@ declare class ComboboxPattern<T extends ListItem<V>, V> {
     onPointerup(event: PointerEvent): void;
     /** Handles input events for the combobox. */
     onInput(event: Event): void;
+    /** Handles focus in events for the combobox. */
     onFocusIn(): void;
     /** Handles focus out events for the combobox. */
     onFocusOut(event: FocusEvent): void;
+    /** The first matching item in the combobox. */
     firstMatch: _angular_core.Signal<T | undefined>;
+    /** Handles filtering logic for the combobox. */
     onFilter(): void;
+    /** Highlights the currently selected item in the combobox. */
     highlight(): void;
     /** Closes the combobox. */
     close(): void;
@@ -513,7 +440,9 @@ declare class ComboboxPattern<T extends ListItem<V>, V> {
     first(): void;
     /** Navigates to the last focusable item in the combobox popup. */
     last(): void;
+    /** Collapses the currently focused item in the combobox. */
     collapseItem(): void;
+    /** Expands the currently focused item in the combobox. */
     expandItem(): void;
     /** Selects an item in the combobox popup. */
     select(opts?: {
@@ -536,7 +465,7 @@ interface ListboxPattern$1<V> {
     listBehavior: List<OptionPattern<V>, V>;
 }
 /** Represents the required inputs for an option in a listbox. */
-interface OptionInputs<V> extends Omit<ListItem<V>, 'index'> {
+interface OptionInputs<V> extends Omit<ListItem<V>, 'index' | 'selectable'> {
     listbox: SignalLike<ListboxPattern$1<V> | undefined>;
 }
 /** Represents an option in a listbox. */
@@ -551,6 +480,8 @@ declare class OptionPattern<V> {
     active: _angular_core.Signal<boolean>;
     /** Whether the option is selected. */
     selected: _angular_core.Signal<boolean | undefined>;
+    /** Whether the option is selectable. */
+    selectable: () => boolean;
     /** Whether the option is disabled. */
     disabled: SignalLike<boolean>;
     /** The text used by the typeahead search. */
@@ -672,8 +603,225 @@ declare class ComboboxListboxPattern<V> extends ListboxPattern<V> implements Com
     setValue: (value: V | undefined) => void;
 }
 
+/** The inputs for the MenuBarPattern class. */
+interface MenuBarInputs<V> extends Omit<ListInputs<MenuItemPattern<V>, V>, 'disabled'> {
+    /** The menu items contained in the menu. */
+    items: SignalLike<MenuItemPattern<V>[]>;
+    /** Callback function triggered when a menu item is selected. */
+    onSubmit?: (value: V) => void;
+}
+/** The inputs for the MenuPattern class. */
+interface MenuInputs<V> extends Omit<ListInputs<MenuItemPattern<V>, V>, 'value' | 'disabled'> {
+    /** The unique ID of the menu. */
+    id: SignalLike<string>;
+    /** The menu items contained in the menu. */
+    items: SignalLike<MenuItemPattern<V>[]>;
+    /** A reference to the parent menu or menu trigger. */
+    parent: SignalLike<MenuTriggerPattern<V> | MenuItemPattern<V> | undefined>;
+    /** Callback function triggered when a menu item is selected. */
+    onSubmit?: (value: V) => void;
+}
+/** The inputs for the MenuTriggerPattern class. */
+interface MenuTriggerInputs<V> {
+    /** A reference to the menu trigger element. */
+    element: SignalLike<HTMLElement | undefined>;
+    /** A reference to the submenu associated with the menu trigger. */
+    submenu: SignalLike<MenuPattern<V> | undefined>;
+    /** Callback function triggered when a menu item is selected. */
+    onSubmit?: (value: V) => void;
+}
+/** The inputs for the MenuItemPattern class. */
+interface MenuItemInputs<V> extends Omit<ListItem<V>, 'index' | 'selectable'> {
+    /** A reference to the parent menu or menu trigger. */
+    parent: SignalLike<MenuPattern<V> | MenuBarPattern<V> | undefined>;
+    /** A reference to the submenu associated with the menu item. */
+    submenu: SignalLike<MenuPattern<V> | undefined>;
+}
+/** The menu ui pattern class. */
+declare class MenuPattern<V> {
+    readonly inputs: MenuInputs<V>;
+    /** The unique ID of the menu. */
+    id: SignalLike<string>;
+    /** The role of the menu. */
+    role: () => string;
+    /** Whether the menu is visible. */
+    isVisible: Signal<boolean>;
+    /** Controls list behavior for the menu items. */
+    listBehavior: List<MenuItemPattern<V>, V>;
+    /** Whether the menu or any of its child elements are currently focused. */
+    isFocused: _angular_core.WritableSignal<boolean>;
+    /** Whether the menu has received focus. */
+    hasBeenFocused: _angular_core.WritableSignal<boolean>;
+    /** Whether the menu should be focused on mouse over. */
+    shouldFocus: Signal<boolean>;
+    /** The key used to expand sub-menus. */
+    private _expandKey;
+    /** The key used to collapse sub-menus. */
+    private _collapseKey;
+    /** Represents the space key. Does nothing when the user is actively using typeahead. */
+    dynamicSpaceKey: Signal<"" | " ">;
+    /** The regexp used to decide if a key should trigger typeahead. */
+    typeaheadRegexp: RegExp;
+    /** The root of the menu. */
+    root: Signal<MenuTriggerPattern<V> | MenuBarPattern<V> | MenuPattern<V> | undefined>;
+    /** Handles keyboard events for the menu. */
+    keydownManager: Signal<KeyboardEventManager<KeyboardEvent>>;
+    constructor(inputs: MenuInputs<V>);
+    /** Sets the default state for the menu. */
+    setDefaultState(): void;
+    /** Handles keyboard events for the menu. */
+    onKeydown(event: KeyboardEvent): void;
+    /** Handles mouseover events for the menu. */
+    onMouseOver(event: MouseEvent): void;
+    /** Handles mouseout events for the menu. */
+    onMouseOut(event: MouseEvent): void;
+    /** Handles click events for the menu. */
+    onClick(event: MouseEvent): void;
+    /** Handles focusin events for the menu. */
+    onFocusIn(): void;
+    /** Handles the focusout event for the menu. */
+    onFocusOut(event: FocusEvent): void;
+    /** Focuses the previous menu item. */
+    prev(): void;
+    /** Focuses the next menu item. */
+    next(): void;
+    /** Focuses the first menu item. */
+    first(): void;
+    /** Focuses the last menu item. */
+    last(): void;
+    /** Triggers the active menu item. */
+    trigger(): void;
+    /** Submits the menu. */
+    submit(item?: MenuItemPattern<V> | undefined): void;
+    /** Collapses the current menu or focuses the previous item in the menubar. */
+    collapse(): void;
+    /** Expands the current menu or focuses the next item in the menubar. */
+    expand(): void;
+    /** Closes the menu and all parent menus. */
+    closeAll(): void;
+}
+/** The menubar ui pattern class. */
+declare class MenuBarPattern<V> {
+    readonly inputs: MenuBarInputs<V>;
+    /** Controls list behavior for the menu items. */
+    listBehavior: List<MenuItemPattern<V>, V>;
+    /** The key used to navigate to the next item. */
+    private _nextKey;
+    /** The key used to navigate to the previous item. */
+    private _previousKey;
+    /** Represents the space key. Does nothing when the user is actively using typeahead. */
+    dynamicSpaceKey: Signal<"" | " ">;
+    /** The regexp used to decide if a key should trigger typeahead. */
+    typeaheadRegexp: RegExp;
+    /** Whether the menubar or any of its children are currently focused. */
+    isFocused: _angular_core.WritableSignal<boolean>;
+    /** Whether the menubar has been focused. */
+    hasBeenFocused: _angular_core.WritableSignal<boolean>;
+    /** Handles keyboard events for the menu. */
+    keydownManager: Signal<KeyboardEventManager<KeyboardEvent>>;
+    constructor(inputs: MenuBarInputs<V>);
+    /** Sets the default state for the menubar. */
+    setDefaultState(): void;
+    /** Handles keyboard events for the menu. */
+    onKeydown(event: KeyboardEvent): void;
+    /** Handles click events for the menu bar. */
+    onClick(event: MouseEvent): void;
+    /** Handles mouseover events for the menu bar. */
+    onMouseOver(event: MouseEvent): void;
+    /** Handles focusin events for the menu bar. */
+    onFocusIn(): void;
+    /** Handles focusout events for the menu bar. */
+    onFocusOut(event: FocusEvent): void;
+    /** Goes to and optionally focuses the specified menu item. */
+    goto(item: MenuItemPattern<V>, opts?: {
+        focusElement?: boolean;
+    }): void;
+    /** Focuses the next menu item. */
+    next(): void;
+    /** Focuses the previous menu item. */
+    prev(): void;
+    /** Closes the menubar and refocuses the root menu bar item. */
+    close(): void;
+}
+/** The menu trigger ui pattern class. */
+declare class MenuTriggerPattern<V> {
+    readonly inputs: MenuTriggerInputs<V>;
+    /** Whether the menu is expanded. */
+    expanded: _angular_core.WritableSignal<boolean>;
+    /** The role of the menu trigger. */
+    role: () => string;
+    /** Whether the menu trigger has a popup. */
+    hasPopup: () => boolean;
+    /** The submenu associated with the trigger. */
+    submenu: SignalLike<MenuPattern<V> | undefined>;
+    /** The tabindex of the menu trigger. */
+    tabindex: Signal<-1 | 0>;
+    /** Handles keyboard events for the menu trigger. */
+    keydownManager: Signal<KeyboardEventManager<KeyboardEvent>>;
+    constructor(inputs: MenuTriggerInputs<V>);
+    /** Handles keyboard events for the menu trigger. */
+    onKeydown(event: KeyboardEvent): void;
+    /** Handles click events for the menu trigger. */
+    onClick(): void;
+    /** Handles focusout events for the menu trigger. */
+    onFocusOut(event: FocusEvent): void;
+    /** Opens the menu. */
+    open(opts?: {
+        first?: boolean;
+        last?: boolean;
+    }): void;
+    /** Closes the menu. */
+    close(opts?: {
+        refocus?: boolean;
+    }): void;
+}
+/** The menu item ui pattern class. */
+declare class MenuItemPattern<V> implements ListItem<V> {
+    readonly inputs: MenuItemInputs<V>;
+    /** The value of the menu item. */
+    value: SignalLike<V>;
+    /** The unique ID of the menu item. */
+    id: SignalLike<string>;
+    /** Whether the menu item is disabled. */
+    disabled: SignalLike<boolean>;
+    /** The search term for the menu item. */
+    searchTerm: SignalLike<string>;
+    /** The element of the menu item. */
+    element: SignalLike<HTMLElement>;
+    /** Whether the menu item is active. */
+    isActive: Signal<boolean>;
+    /** The tabindex of the menu item. */
+    tabindex: Signal<0 | -1>;
+    /** The position of the menu item in the menu. */
+    index: Signal<number>;
+    /** Whether the menu item is expanded. */
+    expanded: Signal<boolean | null>;
+    /** Whether the menu item is expanded. */
+    _expanded: _angular_core.WritableSignal<boolean>;
+    /** The ID of the menu that the menu item controls. */
+    controls: _angular_core.WritableSignal<string | undefined>;
+    /** The role of the menu item. */
+    role: () => string;
+    /** Whether the menu item has a popup. */
+    hasPopup: Signal<boolean>;
+    /** The submenu associated with the menu item. */
+    submenu: SignalLike<MenuPattern<V> | undefined>;
+    /** Whether the menu item is selectable. */
+    selectable: SignalLike<boolean>;
+    constructor(inputs: MenuItemInputs<V>);
+    /** Opens the submenu. */
+    open(opts?: {
+        first?: boolean;
+        last?: boolean;
+    }): void;
+    /** Closes the submenu. */
+    close(opts?: {
+        refocus?: boolean;
+    }): void;
+}
+
 /** Represents the required inputs for a radio button in a radio group. */
-interface RadioButtonInputs<V> extends Omit<ListItem<V>, 'searchTerm' | 'index'> {
+interface RadioButtonInputs<V> extends Omit<ListItem<V>, 'searchTerm' | 'index' | 'selectable'> {
     /** A reference to the parent radio group. */
     group: SignalLike<RadioGroupPattern<V> | undefined>;
 }
@@ -690,6 +838,8 @@ declare class RadioButtonPattern<V> {
     readonly active: _angular_core.Signal<boolean>;
     /** Whether the radio button is selected. */
     readonly selected: SignalLike<boolean>;
+    /** Whether the radio button is selectable. */
+    readonly selectable: () => boolean;
     /** Whether the radio button is disabled. */
     readonly disabled: SignalLike<boolean>;
     /** A reference to the parent radio group. */
@@ -758,7 +908,7 @@ declare class RadioGroupPattern<V> {
 }
 
 /** Represents the required inputs for a toolbar widget in a toolbar. */
-interface ToolbarWidgetInputs<V> extends Omit<ListItem<V>, 'searchTerm' | 'value' | 'index'> {
+interface ToolbarWidgetInputs<V> extends Omit<ListItem<V>, 'searchTerm' | 'value' | 'index' | 'selectable'> {
     /** A reference to the parent toolbar. */
     toolbar: SignalLike<ToolbarPattern<V>>;
 }
@@ -778,6 +928,8 @@ declare class ToolbarWidgetPattern<V> implements ListItem<V> {
     readonly searchTerm: () => string;
     /** The value associated with the widget. */
     readonly value: () => V;
+    /** Whether the widget is selectable. */
+    readonly selectable: () => boolean;
     /** The position of the widget within the toolbar. */
     readonly index: _angular_core.Signal<number>;
     /** Whether the widget is currently the active one (focused). */
@@ -809,7 +961,7 @@ interface ToolbarWidgetGroupControls {
     setDefaultState(): void;
 }
 /** Represents the required inputs for a toolbar widget group. */
-interface ToolbarWidgetGroupInputs<V> extends Omit<ListItem<V>, 'searchTerm' | 'value' | 'index'> {
+interface ToolbarWidgetGroupInputs<V> extends Omit<ListItem<V>, 'searchTerm' | 'value' | 'index' | 'selectable'> {
     /** A reference to the parent toolbar. */
     toolbar: SignalLike<ToolbarPattern<V> | undefined>;
     /** The controls for the sub patterns associated with the toolbar. */
@@ -830,6 +982,8 @@ declare class ToolbarWidgetGroupPattern<V> implements ListItem<V> {
     readonly searchTerm: () => string;
     /** The value associated with the widget. */
     readonly value: () => V;
+    /** Whether the widget is selectable. */
+    readonly selectable: () => boolean;
     /** The position of the widget within the toolbar. */
     readonly index: _angular_core.Signal<number>;
     /** The actions that can be performed on the widget group. */
@@ -1023,7 +1177,7 @@ declare class LabelControl {
 }
 
 /** The required inputs to tabs. */
-interface TabInputs extends Omit<ListItem<string>, 'searchTerm' | 'index'>, Omit<ExpansionItem, 'expansionId' | 'expandable'> {
+interface TabInputs extends Omit<ListItem<string>, 'searchTerm' | 'index' | 'selectable'>, Omit<ExpansionItem, 'expansionId' | 'expandable'> {
     /** The parent tablist that controls the tab. */
     tablist: SignalLike<TabListPattern>;
     /** The remote tabpanel controlled by the tab. */
@@ -1044,6 +1198,8 @@ declare class TabPattern {
     readonly disabled: SignalLike<boolean>;
     /** The html element that should receive focus. */
     readonly element: SignalLike<HTMLElement>;
+    /** Whether the tab is selectable. */
+    readonly selectable: () => boolean;
     /** The text used by the typeahead search. */
     readonly searchTerm: () => string;
     /** Whether this tab has expandable content. */
@@ -1224,13 +1380,27 @@ interface TreeItemInputs<V> extends Omit<ListItem<V>, 'index'> {
     /** 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 {
+declare class TreeItemPattern<V> implements ListItem<V>, ExpansionItem {
     readonly inputs: TreeItemInputs<V>;
+    /** A unique identifier for this item. */
+    readonly id: SignalLike<string>;
+    /** The value of this item. */
+    readonly value: SignalLike<V>;
+    /** A reference to the item element. */
+    readonly element: SignalLike<HTMLElement>;
+    /** Whether the item is disabled. */
+    readonly disabled: SignalLike<boolean>;
+    /** The text used by the typeahead search. */
+    readonly searchTerm: SignalLike<string>;
+    /** The tree pattern this item belongs to. */
+    readonly tree: SignalLike<TreePattern<V>>;
+    /** The parent item. */
+    readonly parent: SignalLike<TreeItemPattern<V> | TreePattern<V>>;
+    /** The children items. */
+    readonly children: SignalLike<TreeItemPattern<V>[]>;
     /** The position of this item among its siblings. */
     readonly index: _angular_core.Signal<number>;
     /** The unique identifier used by the expansion behavior. */
@@ -1241,6 +1411,8 @@ declare class TreeItemPattern<V> implements ExpansionItem {
     readonly expansion: ExpansionControl;
     /** Whether the item is expandable. It's expandable if children item exist. */
     readonly expandable: SignalLike<boolean>;
+    /** Whether the item is selectable. */
+    readonly selectable: SignalLike<boolean>;
     /** The level of the current item in a tree. */
     readonly level: SignalLike<number>;
     /** Whether this item is currently expanded. */
@@ -1256,9 +1428,9 @@ declare class TreeItemPattern<V> implements ExpansionItem {
     /** The tabindex of the item. */
     readonly tabindex: _angular_core.Signal<0 | -1>;
     /** Whether the item is selected. */
-    readonly selected: _angular_core.Signal<boolean | undefined>;
+    readonly selected: SignalLike<boolean | undefined>;
     /** The current type of this item. */
-    readonly current: _angular_core.Signal<"page" | "step" | "location" | "date" | "time" | "true" | "false" | undefined>;
+    readonly current: SignalLike<string | undefined>;
     constructor(inputs: TreeItemInputs<V>);
 }
 /** The selection operations that the tree can perform. */
@@ -1293,7 +1465,7 @@ declare class TreePattern<V> {
     /** The root is always expanded. */
     readonly expanded: () => boolean;
     /** The tabindex of the tree. */
-    tabindex: SignalLike<-1 | 0>;
+    readonly tabindex: SignalLike<-1 | 0>;
     /** The id of the current active item. */
     readonly activedescendant: _angular_core.Signal<string | undefined>;
     /** The direct children of the root (top-level tree items). */
@@ -1318,6 +1490,34 @@ declare class TreePattern<V> {
     readonly keydown: _angular_core.Signal<KeyboardEventManager<KeyboardEvent>>;
     /** The pointerdown event manager for the tree. */
     pointerdown: _angular_core.Signal<PointerEventManager<PointerEvent>>;
+    /** A unique identifier for the tree. */
+    id: SignalLike<string>;
+    /** Whether the tree is in navigation mode. */
+    nav: SignalLike<boolean>;
+    /** The aria-current type. */
+    currentType: SignalLike<'page' | 'step' | 'location' | 'date' | 'time' | 'true' | 'false'>;
+    /** All items in the tree, in document order (DFS-like, a flattened list). */
+    allItems: SignalLike<TreeItemPattern<V>[]>;
+    /** Whether the tree is disabled. */
+    disabled: SignalLike<boolean>;
+    /** The currently active item in the tree. */
+    activeItem: WritableSignalLike<TreeItemPattern<V> | undefined>;
+    /** Whether disabled items should be skipped when navigating. */
+    skipDisabled: SignalLike<boolean>;
+    /** Whether the focus should wrap when navigating past the first or last item. */
+    wrap: SignalLike<boolean>;
+    /** The orientation of the tree. */
+    orientation: SignalLike<'vertical' | 'horizontal'>;
+    /** The text direction of the tree. */
+    textDirection: SignalLike<'ltr' | 'rtl'>;
+    /** Whether multiple items can be selected at the same time. */
+    multi: SignalLike<boolean>;
+    /** The selection mode of the tree. */
+    selectionMode: SignalLike<'follow' | 'explicit'>;
+    /** The delay in milliseconds to wait before clearing the typeahead buffer. */
+    typeaheadDelay: SignalLike<number>;
+    /** The current value of the tree (the selected items). */
+    value: WritableSignalLike<V[]>;
     constructor(inputs: TreeInputs<V>);
     /**
      * Sets the tree to it's default initial state.
@@ -1400,5 +1600,5 @@ declare class ComboboxTreePattern<V> extends TreePattern<V> implements ComboboxT
     collapseAll: () => void;
 }
 
-export { AccordionGroupPattern, AccordionPanelPattern, AccordionTriggerPattern, ComboboxListboxPattern, ComboboxPattern, ComboboxTreePattern, ListboxPattern, OptionPattern, RadioButtonPattern, RadioGroupPattern, TabListPattern, TabPanelPattern, TabPattern, ToolbarPattern, ToolbarRadioGroupPattern, ToolbarWidgetGroupPattern, ToolbarWidgetPattern, TreeItemPattern, TreePattern, convertGetterSetterToWritableSignalLike };
-export type { AccordionGroupInputs, AccordionPanelInputs, AccordionTriggerInputs, ComboboxInputs, ComboboxListboxControls, ComboboxListboxInputs, ComboboxTreeControls, ComboboxTreeInputs, ListboxInputs, OptionInputs, RadioButtonInputs, RadioGroupInputs, SignalLike, TabInputs, TabListInputs, TabPanelInputs, ToolbarInputs, ToolbarRadioGroupInputs, ToolbarWidgetGroupControls, ToolbarWidgetGroupInputs, ToolbarWidgetInputs, TreeInputs, TreeItemInputs, WritableSignalLike };
+export { AccordionGroupPattern, AccordionPanelPattern, AccordionTriggerPattern, ComboboxListboxPattern, ComboboxPattern, ComboboxTreePattern, ListboxPattern, MenuBarPattern, MenuItemPattern, MenuPattern, MenuTriggerPattern, OptionPattern, RadioButtonPattern, RadioGroupPattern, SignalLike, TabListPattern, TabPanelPattern, TabPattern, ToolbarPattern, ToolbarRadioGroupPattern, ToolbarWidgetGroupPattern, ToolbarWidgetPattern, TreeItemPattern, TreePattern, WritableSignalLike };
+export type { AccordionGroupInputs, AccordionPanelInputs, AccordionTriggerInputs, ComboboxInputs, ComboboxListboxControls, ComboboxListboxInputs, ComboboxTreeControls, ComboboxTreeInputs, ListboxInputs, MenuBarInputs, MenuInputs, MenuItemInputs, MenuTriggerInputs, OptionInputs, RadioButtonInputs, RadioGroupInputs, TabInputs, TabListInputs, TabPanelInputs, ToolbarInputs, ToolbarRadioGroupInputs, ToolbarWidgetGroupControls, ToolbarWidgetGroupInputs, ToolbarWidgetInputs, TreeInputs, TreeItemInputs };