@angular/aria 21.1.0-next.1 → 21.1.0-next.3

package/types/_menu-chunk.d.ts

@@ -0,0 +1,267 @@
+import { SignalLike, WritableSignalLike } from './_list-navigation-chunk.js';
+import { KeyboardEventManager } from './_keyboard-event-manager-chunk.js';
+import { ListInputs, ListItem, List } from './_list-chunk.js';
+
+/** The inputs for the MenuBarPattern class. */
+interface MenuBarInputs<V> extends ListInputs<MenuItemPattern<V>, V> {
+    /** The menu items contained in the menu. */
+    items: SignalLike<MenuItemPattern<V>[]>;
+    /** Callback function triggered when a menu item is selected. */
+    onSelect?: (value: V) => void;
+    /** The text direction of the menu bar. */
+    textDirection: SignalLike<'ltr' | 'rtl'>;
+}
+/** The inputs for the MenuPattern class. */
+interface MenuInputs<V> extends Omit<ListInputs<MenuItemPattern<V>, V>, 'values'> {
+    /** 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. */
+    onSelect?: (value: V) => void;
+    /** The text direction of the menu bar. */
+    textDirection: SignalLike<'ltr' | 'rtl'>;
+    /** The delay in milliseconds before expanding sub-menus on hover. */
+    expansionDelay: SignalLike<number>;
+}
+/** The inputs for the MenuTriggerPattern class. */
+interface MenuTriggerInputs<V> {
+    /** A reference to the menu trigger element. */
+    element: SignalLike<HTMLElement | undefined>;
+    /** A reference to the menu associated with the trigger. */
+    menu: SignalLike<MenuPattern<V> | undefined>;
+    /** The text direction of the menu bar. */
+    textDirection: SignalLike<'ltr' | 'rtl'>;
+    /** Whether the menu trigger is disabled. */
+    disabled: SignalLike<boolean>;
+}
+/** 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 disabled. */
+    disabled: () => boolean;
+    /** Whether the menu is visible. */
+    visible: SignalLike<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: WritableSignalLike<boolean>;
+    /** Whether the menu has received focus. */
+    hasBeenFocused: WritableSignalLike<boolean>;
+    /** Whether the menu trigger has been hovered. */
+    hasBeenHovered: WritableSignalLike<boolean>;
+    /** Timeout used to open sub-menus on hover. */
+    _openTimeout: any;
+    /** Timeout used to close sub-menus on hover out. */
+    _closeTimeout: any;
+    /** The tab index of the menu. */
+    tabIndex: () => 0 | -1;
+    /** Whether the menu should be focused on mouse over. */
+    shouldFocus: SignalLike<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: SignalLike<"" | " ">;
+    /** The regexp used to decide if a key should trigger typeahead. */
+    typeaheadRegexp: RegExp;
+    /** The root of the menu. */
+    root: SignalLike<MenuTriggerPattern<V> | MenuBarPattern<V> | MenuPattern<V> | undefined>;
+    /** Handles keyboard events for the menu. */
+    keydownManager: SignalLike<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;
+    /** Closes the specified menu item after a delay. */
+    private _closeItem;
+    /** Opens the specified menu item after a delay. */
+    private _openItem;
+    /** 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. */
+    close(): void;
+    /** Closes the menu and all parent menus. */
+    closeAll(): void;
+    /** Clears any open or close timeouts for sub-menus. */
+    _clearTimeouts(): void;
+    /** Clears the open timeout. */
+    _clearOpenTimeout(): void;
+    /** Clears the close timeout. */
+    _clearCloseTimeout(): 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 tab index of the menu. */
+    tabIndex: () => 0 | -1;
+    /** 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: SignalLike<"" | " ">;
+    /** 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: WritableSignalLike<boolean>;
+    /** Whether the menubar has been focused. */
+    hasBeenFocused: WritableSignalLike<boolean>;
+    /** Whether the menubar is disabled. */
+    disabled: () => boolean;
+    /** Handles keyboard events for the menu. */
+    keydownManager: SignalLike<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: WritableSignalLike<boolean>;
+    /** Whether the menu trigger has received focus. */
+    hasBeenFocused: WritableSignalLike<boolean>;
+    /** The role of the menu trigger. */
+    role: () => string;
+    /** Whether the menu trigger has a popup. */
+    hasPopup: () => boolean;
+    /** The menu associated with the trigger. */
+    menu: SignalLike<MenuPattern<V> | undefined>;
+    /** The tab index of the menu trigger. */
+    tabIndex: SignalLike<-1 | 0>;
+    /** Whether the menu trigger is disabled. */
+    disabled: () => boolean;
+    /** Handles keyboard events for the menu trigger. */
+    keydownManager: SignalLike<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 focusin events for the menu trigger. */
+    onFocusIn(): 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: () => boolean;
+    /** The search term for the menu item. */
+    searchTerm: SignalLike<string>;
+    /** The element of the menu item. */
+    element: SignalLike<HTMLElement | undefined>;
+    /** Whether the menu item is active. */
+    active: SignalLike<boolean>;
+    /** Whether the menu item has received focus. */
+    hasBeenFocused: WritableSignalLike<boolean>;
+    /** The tab index of the menu item. */
+    tabIndex: SignalLike<0 | -1>;
+    /** The position of the menu item in the menu. */
+    index: SignalLike<number>;
+    /** Whether the menu item is expanded. */
+    expanded: SignalLike<boolean | null>;
+    /** Whether the menu item is expanded. */
+    _expanded: WritableSignalLike<boolean>;
+    /** The ID of the menu that the menu item controls. */
+    controls: WritableSignalLike<string | undefined>;
+    /** The role of the menu item. */
+    role: () => string;
+    /** Whether the menu item has a popup. */
+    hasPopup: SignalLike<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;
+    /** Handles focusin events for the menu item. */
+    onFocusIn(): void;
+}
+
+export { MenuBarPattern, MenuItemPattern, MenuPattern, MenuTriggerPattern };
+export type { MenuBarInputs, MenuInputs, MenuItemInputs, MenuTriggerInputs };

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

@@ -0,0 +1,34 @@
+import { EventManager, EventHandlerOptions, ModifierInputs, EventHandler } from './_keyboard-event-manager-chunk.js';
+
+/**
+ * The different mouse buttons that may appear on a pointer event.
+ */
+declare enum MouseButton {
+    Main = 0,
+    Auxiliary = 1,
+    Secondary = 2
+}
+/** An event manager that is specialized for handling pointer events. */
+declare class PointerEventManager<T extends PointerEvent> extends EventManager<T> {
+    options: EventHandlerOptions;
+    /**
+     * Configures this event manager to handle events with a specific modifer and mouse button
+     * combination.
+     */
+    on(button: MouseButton, modifiers: ModifierInputs, handler: EventHandler<T>): this;
+    /**
+     * Configures this event manager to handle events with a specific mouse button and no modifiers.
+     */
+    on(modifiers: ModifierInputs, handler: EventHandler<T>): this;
+    /**
+     * Configures this event manager to handle events with the main mouse button and no modifiers.
+     *
+     * @param handler The handler function
+     * @param options Options for whether to stop propagation or prevent default.
+     */
+    on(handler: EventHandler<T>): this;
+    private _normalizeInputs;
+    _isMatch(event: PointerEvent, button: MouseButton, modifiers: ModifierInputs): boolean;
+}
+
+export { PointerEventManager };

package/types/_tabs-chunk.d.ts

@@ -0,0 +1,153 @@
+import { KeyboardEventManager } from './_keyboard-event-manager-chunk.js';
+import { PointerEventManager } from './_pointer-event-manager-chunk.js';
+import { ExpansionItem, ListExpansionInputs, ListExpansion } from './_expansion-chunk.js';
+import { SignalLike, ListNavigationItem, WritableSignalLike, ListNavigationInputs, ListFocus, ListNavigation } from './_list-navigation-chunk.js';
+
+/** Represents the required inputs for the label control. */
+interface LabelControlInputs {
+    /** The default `aria-labelledby` ids. */
+    defaultLabelledBy: SignalLike<string[]>;
+}
+/** Represents the optional inputs for the label control. */
+interface LabelControlOptionalInputs {
+    /** The `aria-label`. */
+    label?: SignalLike<string | undefined>;
+    /** The user-provided `aria-labelledby` ids. */
+    labelledBy?: SignalLike<string[]>;
+}
+/** Controls label and description of an element. */
+declare class LabelControl {
+    readonly inputs: LabelControlInputs & LabelControlOptionalInputs;
+    /** The `aria-label`. */
+    readonly label: SignalLike<string | undefined>;
+    /** The `aria-labelledby` ids. */
+    readonly labelledBy: SignalLike<string[]>;
+    constructor(inputs: LabelControlInputs & LabelControlOptionalInputs);
+}
+
+/** The required inputs to tabs. */
+interface TabInputs extends Omit<ListNavigationItem, 'index'>, Omit<ExpansionItem, 'expandable'> {
+    /** The parent tablist that controls the tab. */
+    tablist: SignalLike<TabListPattern>;
+    /** The remote tabpanel controlled by the tab. */
+    tabpanel: SignalLike<TabPanelPattern | undefined>;
+    /** The remote tabpanel unique identifier. */
+    value: SignalLike<string>;
+}
+/** A tab in a tablist. */
+declare class TabPattern {
+    readonly inputs: TabInputs;
+    /** A global unique identifier for the tab. */
+    readonly id: SignalLike<string>;
+    /** The index of the tab. */
+    readonly index: SignalLike<number>;
+    /** The remote tabpanel unique identifier. */
+    readonly value: SignalLike<string>;
+    /** Whether the tab is disabled. */
+    readonly disabled: SignalLike<boolean>;
+    /** The html element that should receive focus. */
+    readonly element: SignalLike<HTMLElement>;
+    /** Whether this tab has expandable panel. */
+    readonly expandable: SignalLike<boolean>;
+    /** Whether the tab panel is expanded. */
+    readonly expanded: WritableSignalLike<boolean>;
+    /** Whether the tab is active. */
+    readonly active: SignalLike<boolean>;
+    /** Whether the tab is selected. */
+    readonly selected: SignalLike<boolean>;
+    /** The tab index of the tab. */
+    readonly tabIndex: SignalLike<0 | -1>;
+    /** The id of the tabpanel associated with the tab. */
+    readonly controls: SignalLike<string | undefined>;
+    constructor(inputs: TabInputs);
+    /** Opens the tab. */
+    open(): boolean;
+}
+/** The required inputs for the tabpanel. */
+interface TabPanelInputs extends LabelControlOptionalInputs {
+    /** A global unique identifier for the tabpanel. */
+    id: SignalLike<string>;
+    /** The tab that controls this tabpanel. */
+    tab: SignalLike<TabPattern | undefined>;
+    /** A local unique identifier for the tabpanel. */
+    value: SignalLike<string>;
+}
+/** A tabpanel associated with a tab. */
+declare class TabPanelPattern {
+    readonly inputs: TabPanelInputs;
+    /** A global unique identifier for the tabpanel. */
+    readonly id: SignalLike<string>;
+    /** A local unique identifier for the tabpanel. */
+    readonly value: SignalLike<string>;
+    /** Controls label for this tabpanel. */
+    readonly labelManager: LabelControl;
+    /** Whether the tabpanel is hidden. */
+    readonly hidden: SignalLike<boolean>;
+    /** The tab index of this tabpanel. */
+    readonly tabIndex: SignalLike<-1 | 0>;
+    /** The aria-labelledby value for this tabpanel. */
+    readonly labelledBy: SignalLike<string | undefined>;
+    constructor(inputs: TabPanelInputs);
+}
+/** The required inputs for the tablist. */
+interface TabListInputs extends Omit<ListNavigationInputs<TabPattern>, 'multi'>, Omit<ListExpansionInputs, 'multiExpandable' | 'items'> {
+    /** The selection strategy used by the tablist. */
+    selectionMode: SignalLike<'follow' | 'explicit'>;
+}
+/** Controls the state of a tablist. */
+declare class TabListPattern {
+    readonly inputs: TabListInputs;
+    /** The list focus behavior for the tablist. */
+    readonly focusBehavior: ListFocus<TabPattern>;
+    /** The list navigation behavior for the tablist. */
+    readonly navigationBehavior: ListNavigation<TabPattern>;
+    /** Controls expansion for the tablist. */
+    readonly expansionBehavior: ListExpansion;
+    /** The currently active tab. */
+    readonly activeTab: SignalLike<TabPattern | undefined>;
+    /** The currently selected tab. */
+    readonly selectedTab: WritableSignalLike<TabPattern | undefined>;
+    /** Whether the tablist is vertically or horizontally oriented. */
+    readonly orientation: SignalLike<'vertical' | 'horizontal'>;
+    /** Whether the tablist is disabled. */
+    readonly disabled: SignalLike<boolean>;
+    /** The tab index of the tablist. */
+    readonly tabIndex: SignalLike<0 | -1>;
+    /** The id of the current active tab. */
+    readonly activeDescendant: SignalLike<string | undefined>;
+    /** Whether selection should follow focus. */
+    readonly followFocus: SignalLike<boolean>;
+    /** The key used to navigate to the previous tab in the tablist. */
+    readonly prevKey: SignalLike<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
+    /** The key used to navigate to the next item in the list. */
+    readonly nextKey: SignalLike<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
+    /** The keydown event manager for the tablist. */
+    readonly keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
+    /** The pointerdown event manager for the tablist. */
+    readonly pointerdown: SignalLike<PointerEventManager<PointerEvent>>;
+    constructor(inputs: TabListInputs);
+    /**
+     * Sets the tablist to its default initial state.
+     *
+     * Sets the active index of the tablist to the first focusable selected
+     * tab if one exists. Otherwise, sets focus to the first focusable tab.
+     *
+     * This method should be called once the tablist and its tabs are properly initialized.
+     */
+    setDefaultState(): void;
+    /** Handles keydown events for the tablist. */
+    onKeydown(event: KeyboardEvent): void;
+    /** The pointerdown event manager for the tablist. */
+    onPointerdown(event: PointerEvent): void;
+    /** Opens the tab by given value. */
+    open(value: string): boolean;
+    /** Opens the given tab or the current active tab. */
+    open(tab?: TabPattern): boolean;
+    /** Executes a navigation operation and expand the active tab if needed. */
+    private _navigate;
+    /** Returns the tab item associated with the given pointer event. */
+    private _getItem;
+}
+
+export { TabListPattern, TabPanelPattern, TabPattern };
+export type { TabInputs, TabListInputs, TabPanelInputs };

package/types/_toolbar-chunk.d.ts

@@ -0,0 +1,124 @@
+import { SignalLike } from './_list-navigation-chunk.js';
+import { ListItem, ListInputs, List } from './_list-chunk.js';
+
+/** Represents the required inputs for a toolbar widget group. */
+interface ToolbarWidgetGroupInputs<T extends ListItem<V>, V> {
+    /** A reference to the parent toolbar. */
+    toolbar: SignalLike<ToolbarPattern<V> | undefined>;
+    /** Whether the widget group is disabled. */
+    disabled: SignalLike<boolean>;
+    /** The list of items within the widget group. */
+    items: SignalLike<T[]>;
+    /** Whether the group allows multiple widgets to be selected. */
+    multi: SignalLike<boolean>;
+}
+/** A group of widgets within a toolbar that provides nested navigation. */
+declare class ToolbarWidgetGroupPattern<T extends ListItem<V>, V> {
+    readonly inputs: ToolbarWidgetGroupInputs<T, V>;
+    /** Whether the widget is disabled. */
+    readonly disabled: () => boolean;
+    /** A reference to the parent toolbar. */
+    readonly toolbar: () => ToolbarPattern<V> | undefined;
+    /** Whether the group allows multiple widgets to be selected. */
+    readonly multi: () => boolean;
+    readonly searchTerm: () => string;
+    readonly value: () => V;
+    readonly selectable: () => boolean;
+    readonly element: () => undefined;
+    constructor(inputs: ToolbarWidgetGroupInputs<T, V>);
+}
+
+/** Represents the required inputs for a toolbar widget in a toolbar. */
+interface ToolbarWidgetInputs<V> extends Omit<ListItem<V>, 'searchTerm' | 'index' | 'selectable'> {
+    /** A reference to the parent toolbar. */
+    toolbar: SignalLike<ToolbarPattern<V>>;
+    /** A reference to the parent widget group. */
+    group: SignalLike<ToolbarWidgetGroupPattern<ToolbarWidgetPattern<V>, V> | undefined>;
+}
+declare class ToolbarWidgetPattern<V> implements ListItem<V> {
+    readonly inputs: ToolbarWidgetInputs<V>;
+    /** A unique identifier for the widget. */
+    readonly id: () => string;
+    /** The html element that should receive focus. */
+    readonly element: () => HTMLElement | undefined;
+    /** Whether the widget is disabled. */
+    readonly disabled: () => boolean;
+    /** A reference to the parent toolbar. */
+    readonly group: () => ToolbarWidgetGroupPattern<ToolbarWidgetPattern<V>, V> | undefined;
+    /** A reference to the toolbar containing the widget. */
+    readonly toolbar: () => ToolbarPattern<V>;
+    /** The tabindex of the widget. */
+    readonly tabIndex: SignalLike<0 | -1>;
+    /** The text used by the typeahead search. */
+    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: SignalLike<number>;
+    /** Whether the widget is selected (only relevant in a selection group). */
+    readonly selected: SignalLike<boolean>;
+    /** Whether the widget is currently the active one (focused). */
+    readonly active: SignalLike<boolean>;
+    constructor(inputs: ToolbarWidgetInputs<V>);
+}
+
+/** Represents the required inputs for a toolbar. */
+type ToolbarInputs<V> = Omit<ListInputs<ToolbarWidgetPattern<V>, V>, 'multi' | 'typeaheadDelay' | 'selectionMode' | 'focusMode'> & {
+    /** A function that returns the toolbar item associated with a given element. */
+    getItem: (e: Element) => ToolbarWidgetPattern<V> | undefined;
+};
+/** Controls the state of a toolbar. */
+declare class ToolbarPattern<V> {
+    readonly inputs: ToolbarInputs<V>;
+    /** The list behavior for the toolbar. */
+    readonly listBehavior: List<ToolbarWidgetPattern<V>, V>;
+    /** Whether the tablist is vertically or horizontally oriented. */
+    readonly orientation: SignalLike<'vertical' | 'horizontal'>;
+    /** Whether disabled items in the group should be focusable. */
+    readonly softDisabled: SignalLike<boolean>;
+    /** Whether the toolbar is disabled. */
+    readonly disabled: SignalLike<boolean>;
+    /** The tab index of the toolbar (if using activedescendant). */
+    readonly tabIndex: SignalLike<0 | -1>;
+    /** The id of the current active widget (if using activedescendant). */
+    readonly activeDescendant: SignalLike<string | undefined>;
+    /** The currently active item in the toolbar. */
+    readonly activeItem: () => ToolbarWidgetPattern<V> | undefined;
+    /** The key used to navigate to the previous widget. */
+    private readonly _prevKey;
+    /** The key used to navigate to the next widget. */
+    private readonly _nextKey;
+    /** The alternate key used to navigate to the previous widget. */
+    private readonly _altPrevKey;
+    /** The alternate key used to navigate to the next widget. */
+    private readonly _altNextKey;
+    /** The keydown event manager for the toolbar. */
+    private readonly _keydown;
+    /** Navigates to the next widget in a widget group. */
+    private _groupNext;
+    /** Navigates to the previous widget in a widget group. */
+    private _groupPrev;
+    /** Navigates to the widget targeted by a pointer event. */
+    private _goto;
+    select(): void;
+    constructor(inputs: ToolbarInputs<V>);
+    /** Handles keydown events for the toolbar. */
+    onKeydown(event: KeyboardEvent): void;
+    onPointerdown(event: PointerEvent): void;
+    /** Handles click events for the toolbar. */
+    onClick(event: MouseEvent): void;
+    /**
+     * Sets the toolbar to its default initial state.
+     *
+     * Sets the active index to the selected widget if one exists and is focusable.
+     * Otherwise, sets the active index to the first focusable widget.
+     */
+    setDefaultState(): void;
+    /** Validates the state of the toolbar and returns a list of accessibility violations. */
+    validate(): string[];
+}
+
+export { ToolbarPattern, ToolbarWidgetGroupPattern, ToolbarWidgetPattern };
+export type { ToolbarInputs, ToolbarWidgetGroupInputs, ToolbarWidgetInputs };