@angular/aria 0.0.1 → 21.0.0-next.9

package/types/accordion.d.ts

@@ -0,0 +1,92 @@
+import * as _angular_cdk_bidi from '@angular/cdk/bidi';
+import * as _angular_core from '@angular/core';
+import { WritableSignal } from '@angular/core';
+import { AccordionTriggerPattern, AccordionPanelPattern, AccordionGroupPattern } from '@angular/aria/ui-patterns';
+import * as i1 from '@angular/aria/deferred-content';
+
+/**
+ * Represents the content panel of an accordion item. It is controlled by an
+ * associated `AccordionTrigger`.
+ */
+declare class AccordionPanel {
+    /** The DeferredContentAware host directive. */
+    private readonly _deferredContentAware;
+    /** A global unique identifier for the panel. */
+    private readonly _id;
+    /** A local unique identifier for the panel, used to match with its trigger's value. */
+    value: _angular_core.InputSignal<string>;
+    /** The parent accordion trigger pattern that controls this panel. This is set by AccordionGroup. */
+    readonly accordionTrigger: WritableSignal<AccordionTriggerPattern | undefined>;
+    /** The UI pattern instance for this panel. */
+    readonly pattern: AccordionPanelPattern;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionPanel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionPanel, "[ngAccordionPanel]", ["ngAccordionPanel"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.DeferredContentAware; inputs: { "preserveContent": "preserveContent"; }; outputs: {}; }]>;
+}
+/**
+ * Represents the trigger button for an accordion item. It controls the expansion
+ * state of an associated `AccordionPanel`.
+ */
+declare class AccordionTrigger {
+    /** A global unique identifier for the trigger. */
+    private readonly _id;
+    /** A reference to the trigger element. */
+    private readonly _elementRef;
+    /** The parent AccordionGroup. */
+    private readonly _accordionGroup;
+    /** A local unique identifier for the trigger, used to match with its panel's value. */
+    value: _angular_core.InputSignal<string>;
+    /** Whether the trigger is disabled. */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether this trigger is completely inaccessible.
+     *
+     * TODO(ok7sai): Consider move this to UI patterns.
+     */
+    readonly hardDisabled: _angular_core.Signal<boolean>;
+    /** The accordion panel pattern controlled by this trigger. This is set by AccordionGroup. */
+    readonly accordionPanel: WritableSignal<AccordionPanelPattern | undefined>;
+    /** The UI pattern instance for this trigger. */
+    readonly pattern: AccordionTriggerPattern;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionTrigger, "[ngAccordionTrigger]", ["ngAccordionTrigger"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Container for a group of accordion items. It manages the overall state and
+ * interactions of the accordion, such as keyboard navigation and expansion mode.
+ */
+declare class AccordionGroup {
+    /** A reference to the group element. */
+    private readonly _elementRef;
+    /** The AccordionTriggers nested inside this group. */
+    protected readonly _triggers: _angular_core.Signal<readonly AccordionTrigger[]>;
+    /** The AccordionPanels nested inside this group. */
+    protected readonly _panels: _angular_core.Signal<readonly AccordionPanel[]>;
+    /** The text direction (ltr or rtl). */
+    readonly textDirection: WritableSignal<_angular_cdk_bidi.Direction>;
+    /** Whether the entire accordion group is disabled. */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether multiple accordion items can be expanded simultaneously. */
+    multiExpandable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The values of the current selected/expanded accordions. */
+    value: _angular_core.ModelSignal<string[]>;
+    /** Whether disabled items should be skipped during keyboard navigation. */
+    skipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether keyboard navigation should wrap around from the last item to the first, and vice-versa. */
+    wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The UI pattern instance for this accordion group. */
+    readonly pattern: AccordionGroupPattern;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionGroup, "[ngAccordionGroup]", ["ngAccordionGroup"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "multiExpandable": { "alias": "multiExpandable"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "skipDisabled": { "alias": "skipDisabled"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["_triggers", "_panels"], never, true, never>;
+}
+/**
+ * A structural directive that marks the `ng-template` to be used as the content
+ * for a `AccordionPanel`. This content can be lazily loaded.
+ */
+declare class AccordionContent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionContent, "ng-template[ngAccordionContent]", never, {}, {}, never, never, true, [{ directive: typeof i1.DeferredContent; inputs: {}; outputs: {}; }]>;
+}
+
+export { AccordionContent, AccordionGroup, AccordionPanel, AccordionTrigger };

package/types/aria.d.ts

@@ -0,0 +1,6 @@
+import { Version } from '@angular/core';
+
+/** Current version of the CDK Experimental package. */
+declare const VERSION: Version;
+
+export { VERSION };

package/types/combobox.d.ts

@@ -0,0 +1,51 @@
+import * as _angular_core from '@angular/core';
+import { WritableSignal } from '@angular/core';
+import { ComboboxPattern, ComboboxListboxControls, ComboboxTreeControls } from '@angular/aria/ui-patterns';
+import * as i1 from '@angular/aria/deferred-content';
+
+declare class Combobox<V> {
+    /** The element that the combobox is attached to. */
+    private readonly _elementRef;
+    /** The DeferredContentAware host directive. */
+    private readonly _deferredContentAware;
+    /** The combobox popup. */
+    readonly popup: _angular_core.Signal<ComboboxPopup<V> | undefined>;
+    /** The filter mode for the combobox. */
+    filterMode: _angular_core.InputSignal<"manual" | "auto-select" | "highlight">;
+    /** Whether the combobox is focused. */
+    readonly isFocused: WritableSignal<boolean>;
+    /** The value of the first matching item in the popup. */
+    firstMatch: _angular_core.InputSignal<V | undefined>;
+    /** Whether the listbox has received focus yet. */
+    private _hasBeenFocused;
+    /** The combobox ui pattern. */
+    readonly pattern: ComboboxPattern<any, V>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Combobox<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Combobox<any>, "[ngCombobox]", ["ngCombobox"], { "filterMode": { "alias": "filterMode"; "required": false; "isSignal": true; }; "firstMatch": { "alias": "firstMatch"; "required": false; "isSignal": true; }; }, {}, ["popup"], never, true, [{ directive: typeof i1.DeferredContentAware; inputs: { "preserveContent": "preserveContent"; }; outputs: {}; }]>;
+}
+declare class ComboboxInput {
+    /** The element that the combobox is attached to. */
+    private readonly _elementRef;
+    /** The combobox that the input belongs to. */
+    readonly combobox: Combobox<any>;
+    /** The value of the input. */
+    value: _angular_core.ModelSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComboboxInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ComboboxInput, "input[ngComboboxInput]", ["ngComboboxInput"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+declare class ComboboxPopupContainer {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComboboxPopupContainer, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ComboboxPopupContainer, "ng-template[ngComboboxPopupContainer]", ["ngComboboxPopupContainer"], {}, {}, never, never, true, [{ directive: typeof i1.DeferredContent; inputs: {}; outputs: {}; }]>;
+}
+declare class ComboboxPopup<V> {
+    /** The combobox that the popup belongs to. */
+    readonly combobox: Combobox<V> | null;
+    /** The controls the popup exposes to the combobox. */
+    readonly controls: WritableSignal<ComboboxListboxControls<any, V> | ComboboxTreeControls<any, V> | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComboboxPopup<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ComboboxPopup<any>, "[ngComboboxPopup]", ["ngComboboxPopup"], {}, {}, never, never, true, never>;
+}
+
+export { Combobox, ComboboxInput, ComboboxPopup, ComboboxPopupContainer };

package/types/deferred-content.d.ts

@@ -0,0 +1,38 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * A container directive controls the visibility of its content.
+ */
+declare class DeferredContentAware {
+    readonly contentVisible: _angular_core.WritableSignal<boolean>;
+    readonly preserveContent: _angular_core.ModelSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DeferredContentAware, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DeferredContentAware, never, never, { "preserveContent": { "alias": "preserveContent"; "required": false; "isSignal": true; }; }, { "preserveContent": "preserveContentChange"; }, never, never, true, never>;
+}
+/**
+ * DeferredContent loads/unloads the content based on the visibility.
+ * The visibilty signal is sent from a parent directive implements
+ * DeferredContentAware.
+ *
+ * Use this directive as a host directive. For example:
+ *
+ * ```ts
+ *   @Directive({
+ *     selector: 'ng-template[AccordionContent]',
+ *     hostDirectives: [DeferredContent],
+ *   })
+ *   class AccordionContent {}
+ * ```
+ */
+declare class DeferredContent {
+    private readonly _deferredContentAware;
+    private readonly _templateRef;
+    private readonly _viewContainerRef;
+    private _isRendered;
+    readonly deferredContentAware: _angular_core.WritableSignal<DeferredContentAware | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DeferredContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DeferredContent, never, never, {}, {}, never, never, true, never>;
+}
+
+export { DeferredContent, DeferredContentAware };

package/types/listbox.d.ts

@@ -0,0 +1,95 @@
+import * as _angular_cdk_bidi from '@angular/cdk/bidi';
+import * as _angular_core from '@angular/core';
+import { OptionPattern, ListboxPattern } from '@angular/aria/ui-patterns';
+import { ComboboxPopup } from './combobox.js';
+import '@angular/aria/deferred-content';
+
+/**
+ * A listbox container.
+ *
+ * Listboxes are used to display a list of items for a user to select from. The Listbox is meant
+ * to be used in conjunction with Option as follows:
+ *
+ * ```html
+ * <ul ngListbox>
+ *   <li [value]="1" ngOption>Item 1</li>
+ *   <li [value]="2" ngOption>Item 2</li>
+ *   <li [value]="3" ngOption>Item 3</li>
+ * </ul>
+ * ```
+ */
+declare class Listbox<V> {
+    /** A unique identifier for the listbox. */
+    private readonly _generatedId;
+    /** A unique identifier for the listbox. */
+    protected id: _angular_core.Signal<string>;
+    /** A reference to the parent combobox popup, if one exists. */
+    private readonly _popup;
+    /** A reference to the listbox element. */
+    private readonly _elementRef;
+    /** The directionality (LTR / RTL) context for the application (or a subtree of it). */
+    private readonly _directionality;
+    /** The Options nested inside of the Listbox. */
+    private readonly _options;
+    /** A signal wrapper for directionality. */
+    protected textDirection: _angular_core.Signal<_angular_cdk_bidi.Direction>;
+    /** The Option UIPatterns of the child Options. */
+    protected items: _angular_core.Signal<OptionPattern<any>[]>;
+    /** Whether the list is vertically or horizontally oriented. */
+    orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    /** Whether multiple items in the list can be selected at once. */
+    multi: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether focus should wrap when navigating. */
+    wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether disabled items in the list should be skipped when navigating. */
+    skipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The focus strategy used by the list. */
+    focusMode: _angular_core.InputSignal<"roving" | "activedescendant">;
+    /** The selection strategy used by the list. */
+    selectionMode: _angular_core.InputSignal<"follow" | "explicit">;
+    /** The amount of time before the typeahead search is reset. */
+    typeaheadDelay: _angular_core.InputSignal<number>;
+    /** Whether the listbox is disabled. */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the listbox is readonly. */
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The values of the current selected items. */
+    value: _angular_core.ModelSignal<V[]>;
+    /** The Listbox UIPattern. */
+    pattern: ListboxPattern<V>;
+    /** Whether the listbox has received focus yet. */
+    private _hasFocused;
+    constructor();
+    onFocus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Listbox<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Listbox<any>, "[ngListbox]", ["ngListbox"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "skipDisabled": { "alias": "skipDisabled"; "required": false; "isSignal": true; }; "focusMode": { "alias": "focusMode"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "typeaheadDelay": { "alias": "typeaheadDelay"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["_options"], never, true, [{ directive: typeof ComboboxPopup; inputs: {}; outputs: {}; }]>;
+}
+/** A selectable option in a Listbox. */
+declare class Option<V> {
+    /** A reference to the option element. */
+    private readonly _elementRef;
+    /** The parent Listbox. */
+    private readonly _listbox;
+    /** A unique identifier for the option. */
+    private readonly _generatedId;
+    /** A unique identifier for the option. */
+    protected id: _angular_core.Signal<string>;
+    /** The text used by the typeahead search. */
+    protected searchTerm: _angular_core.Signal<any>;
+    /** The parent Listbox UIPattern. */
+    protected listbox: _angular_core.Signal<ListboxPattern<any>>;
+    /** A reference to the option element to be focused on navigation. */
+    protected element: _angular_core.Signal<any>;
+    /** The value of the option. */
+    value: _angular_core.InputSignal<V>;
+    /** Whether an item is disabled. */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The text used by the typeahead search. */
+    label: _angular_core.InputSignal<string | undefined>;
+    /** The Option UIPattern. */
+    pattern: OptionPattern<V>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Option<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Option<any>, "[ngOption]", ["ngOption"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { Listbox, Option };

package/types/radio-group.d.ts

@@ -0,0 +1,82 @@
+import * as _angular_core from '@angular/core';
+import { WritableSignal } from '@angular/core';
+import * as _angular_cdk_bidi from '@angular/cdk/bidi';
+import { RadioButtonPattern, RadioGroupPattern } from '@angular/aria/ui-patterns';
+import * as i1 from '@angular/aria/toolbar';
+
+/**
+ * A radio button group container.
+ *
+ * Radio groups are used to group multiple radio buttons or radio group labels so they function as
+ * a single form control. The RadioGroup is meant to be used in conjunction with RadioButton
+ * as follows:
+ *
+ * ```html
+ * <div ngRadioGroup>
+ *   <div ngRadioButton value="1">Option 1</div>
+ *   <div ngRadioButton value="2">Option 2</div>
+ *   <div ngRadioButton value="3">Option 3</div>
+ * </div>
+ * ```
+ */
+declare class RadioGroup<V> {
+    /** A reference to the radio group element. */
+    private readonly _elementRef;
+    /** A reference to the ToolbarWidgetGroup, if the radio group is in a toolbar. */
+    private readonly _toolbarWidgetGroup;
+    /** Whether the radio group is inside of a Toolbar. */
+    private readonly _hasToolbar;
+    /** The RadioButtons nested inside of the RadioGroup. */
+    private readonly _radioButtons;
+    /** A signal wrapper for directionality. */
+    protected textDirection: WritableSignal<_angular_cdk_bidi.Direction>;
+    /** The RadioButton UIPatterns of the child RadioButtons. */
+    protected items: _angular_core.Signal<RadioButtonPattern<any>[]>;
+    /** Whether the radio group is vertically or horizontally oriented. */
+    readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    /** Whether disabled items in the group should be skipped when navigating. */
+    readonly skipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The focus strategy used by the radio group. */
+    readonly focusMode: _angular_core.InputSignal<"roving" | "activedescendant">;
+    /** Whether the radio group is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the radio group is readonly. */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The value of the currently selected radio button. */
+    readonly value: _angular_core.ModelSignal<V | null>;
+    /** The internal selection state for the radio group. */
+    private readonly _value;
+    /** The RadioGroup UIPattern. */
+    readonly pattern: RadioGroupPattern<V>;
+    /** Whether the radio group has received focus yet. */
+    private _hasFocused;
+    constructor();
+    onFocus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioGroup<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RadioGroup<any>, "[ngRadioGroup]", ["ngRadioGroup"], { "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"; }, ["_radioButtons"], never, true, [{ directive: typeof i1.ToolbarWidgetGroup; inputs: { "disabled": "disabled"; }; outputs: {}; }]>;
+}
+/** A selectable radio button in a RadioGroup. */
+declare class RadioButton<V> {
+    /** A reference to the radio button element. */
+    private readonly _elementRef;
+    /** The parent RadioGroup. */
+    private readonly _radioGroup;
+    /** A unique identifier for the radio button. */
+    private readonly _generatedId;
+    /** A unique identifier for the radio button. */
+    readonly id: _angular_core.Signal<string>;
+    /** The value associated with the radio button. */
+    readonly value: _angular_core.InputSignal<V>;
+    /** The parent RadioGroup UIPattern. */
+    readonly group: _angular_core.Signal<RadioGroupPattern<any>>;
+    /** A reference to the radio button element to be focused on navigation. */
+    element: _angular_core.Signal<any>;
+    /** Whether the radio button is disabled. */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The RadioButton UIPattern. */
+    pattern: RadioButtonPattern<V>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioButton<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RadioButton<any>, "[ngRadioButton]", ["ngRadioButton"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { RadioButton, RadioGroup };

package/types/tabs.d.ts

@@ -0,0 +1,156 @@
+import * as _angular_core from '@angular/core';
+import { Signal, OnInit, OnDestroy } from '@angular/core';
+import * as _angular_cdk_bidi from '@angular/cdk/bidi';
+import { TabPattern, TabPanelPattern, TabListPattern } from '@angular/aria/ui-patterns';
+import * as i1 from '@angular/aria/deferred-content';
+
+interface HasElement {
+    element: Signal<HTMLElement>;
+}
+/**
+ * A Tabs container.
+ *
+ * Represents a set of layered sections of content. The Tabs is a container meant to be used with
+ * TabList, Tab, and TabPanel as follows:
+ *
+ * ```html
+ * <div ngTabs>
+ *   <ul ngTabList>
+ *     <li ngTab value="tab1">Tab 1</li>
+ *     <li ngTab value="tab2">Tab 2</li>
+ *     <li ngTab value="tab3">Tab 3</li>
+ *   </ul>
+ *
+ *   <div ngTabPanel value="tab1">
+ *      <ng-template ngTabContent>Tab content 1</ng-template>
+ *   </div>
+ *   <div ngTabPanel value="tab2">
+ *      <ng-template ngTabContent>Tab content 2</ng-template>
+ *   </div>
+ *   <div ngTabPanel value="tab3">
+ *      <ng-template ngTabContent>Tab content 3</ng-template>
+ *   </div>
+ * ```
+ */
+declare class Tabs {
+    /** The TabList nested inside of the container. */
+    private readonly _tablist;
+    /** The TabPanels nested inside of the container. */
+    private readonly _unorderedPanels;
+    /** The Tab UIPattern of the child Tabs. */
+    tabs: Signal<TabPattern[] | undefined>;
+    /** The TabPanel UIPattern of the child TabPanels. */
+    unorderedTabpanels: Signal<TabPanelPattern[]>;
+    register(child: TabList | TabPanel): void;
+    deregister(child: TabList | TabPanel): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tabs, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Tabs, "[ngTabs]", ["ngTabs"], {}, {}, never, never, true, never>;
+}
+/**
+ * A TabList container.
+ *
+ * Controls a list of Tab(s).
+ */
+declare class TabList implements OnInit, OnDestroy {
+    /** A reference to the tab list element. */
+    private readonly _elementRef;
+    /** The parent Tabs. */
+    private readonly _tabs;
+    /** The Tabs nested inside of the TabList. */
+    private readonly _unorderedTabs;
+    /** The internal tab selection state. */
+    private readonly _selection;
+    /** Text direction. */
+    readonly textDirection: _angular_core.WritableSignal<_angular_cdk_bidi.Direction>;
+    /** The Tab UIPatterns of the child Tabs. */
+    readonly tabs: Signal<TabPattern[]>;
+    /** Whether the tablist is vertically or horizontally oriented. */
+    readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    /** Whether focus should wrap when navigating. */
+    readonly wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether disabled items in the list should be skipped when navigating. */
+    readonly skipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The focus strategy used by the tablist. */
+    readonly focusMode: _angular_core.InputSignal<"roving" | "activedescendant">;
+    /** The selection strategy used by the tablist. */
+    readonly selectionMode: _angular_core.InputSignal<"follow" | "explicit">;
+    /** Whether the tablist is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The current selected tab. */
+    readonly selectedTab: _angular_core.ModelSignal<string | undefined>;
+    /** 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;
+    deregister(child: Tab): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabList, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabList, "[ngTabList]", ["ngTabList"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "skipDisabled": { "alias": "skipDisabled"; "required": false; "isSignal": true; }; "focusMode": { "alias": "focusMode"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selectedTab": { "alias": "selectedTab"; "required": false; "isSignal": true; }; }, { "selectedTab": "selectedTabChange"; }, never, never, true, never>;
+}
+/** A selectable tab in a TabList. */
+declare class Tab implements HasElement, OnInit, OnDestroy {
+    /** A reference to the tab element. */
+    private readonly _elementRef;
+    /** The parent Tabs. */
+    private readonly _tabs;
+    /** The parent TabList. */
+    private readonly _tabList;
+    /** A global unique identifier for the tab. */
+    private readonly _id;
+    /** The host native element. */
+    readonly element: Signal<any>;
+    /** The parent TabList UIPattern. */
+    readonly tablist: Signal<TabListPattern>;
+    /** The TabPanel UIPattern associated with the tab */
+    readonly tabpanel: Signal<TabPanelPattern | undefined>;
+    /** Whether a tab is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** A local unique identifier for the tab. */
+    readonly value: _angular_core.InputSignal<string>;
+    /** The Tab UIPattern. */
+    readonly pattern: TabPattern;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tab, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Tab, "[ngTab]", ["ngTab"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * A TabPanel container for the resources of layered content associated with a tab.
+ *
+ * If a tabpanel is hidden due to its corresponding tab is not activated, the `inert` attribute
+ * will be applied to the tabpanel element to remove it from the accessibility tree and stop
+ * all the keyboard and pointer interactions. Note that this does not visually hide the tabpenl
+ * and a proper styling is required.
+ */
+declare class TabPanel implements OnInit, OnDestroy {
+    /** The DeferredContentAware host directive. */
+    private readonly _deferredContentAware;
+    /** The parent Tabs. */
+    private readonly _Tabs;
+    /** A global unique identifier for the tab. */
+    private readonly _id;
+    /** The Tab UIPattern associated with the tabpanel */
+    readonly tab: Signal<TabPattern | undefined>;
+    /** A local unique identifier for the tabpanel. */
+    readonly value: _angular_core.InputSignal<string>;
+    /** The TabPanel UIPattern. */
+    readonly pattern: TabPanelPattern;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabPanel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabPanel, "[ngTabPanel]", ["ngTabPanel"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.DeferredContentAware; inputs: { "preserveContent": "preserveContent"; }; outputs: {}; }]>;
+}
+/**
+ * A TabContent container for the lazy-loaded content.
+ */
+declare class TabContent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabContent, "ng-template[ngTabContent]", ["ngTabContent"], {}, {}, never, never, true, [{ directive: typeof i1.DeferredContent; inputs: {}; outputs: {}; }]>;
+}
+
+export { Tab, TabContent, TabList, TabPanel, Tabs };

package/types/toolbar.d.ts

@@ -0,0 +1,113 @@
+import * as _angular_core from '@angular/core';
+import { Signal, OnInit, OnDestroy } from '@angular/core';
+import * as _angular_cdk_bidi from '@angular/cdk/bidi';
+import { ToolbarWidgetPattern, ToolbarWidgetGroupPattern, ToolbarPattern, ToolbarWidgetGroupControls } from '@angular/aria/ui-patterns';
+
+/**
+ * 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 Toolbar is meant to be used in conjunction
+ * with ToolbarWidget and RadioGroup as follows:
+ *
+ * ```html
+ * <div ngToolbar>
+ *  <button ngToolbarWidget>Button</button>
+ *  <div ngRadioGroup>
+ *    <label ngRadioButton value="1">Option 1</label>
+ *    <label ngRadioButton value="2">Option 2</label>
+ *    <label ngRadioButton value="3">Option 3</label>
+ *  </div>
+ * </div>
+ * ```
+ */
+declare class Toolbar<V> {
+    /** A reference to the toolbar element. */
+    private readonly _elementRef;
+    /** The TabList nested inside of the container. */
+    private readonly _widgets;
+    /** A signal wrapper for directionality. */
+    readonly textDirection: _angular_core.WritableSignal<_angular_cdk_bidi.Direction>;
+    /** Sorted UIPatterns of the child widgets */
+    readonly items: Signal<(ToolbarWidgetPattern<V> | ToolbarWidgetGroupPattern<V>)[]>;
+    /** Whether the toolbar is vertically or horizontally oriented. */
+    readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    /** Whether disabled items in the group should be skipped when navigating. */
+    readonly skipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the toolbar is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether focus should wrap when navigating. */
+    readonly wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The toolbar UIPattern. */
+    readonly pattern: ToolbarPattern<V>;
+    /** Whether the toolbar has received focus yet. */
+    private _hasFocused;
+    constructor();
+    onFocus(): void;
+    register(widget: ToolbarWidget<V> | ToolbarWidgetGroup<V>): void;
+    unregister(widget: ToolbarWidget<V> | ToolbarWidgetGroup<V>): void;
+    /** Finds the toolbar item associated with a given element. */
+    private _getItem;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Toolbar<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Toolbar<any>, "[ngToolbar]", ["ngToolbar"], { "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 ToolbarWidget<V> implements OnInit, OnDestroy {
+    /** A reference to the widget element. */
+    private readonly _elementRef;
+    /** The parent Toolbar. */
+    private readonly _toolbar;
+    /** A unique identifier for the widget. */
+    private readonly _generatedId;
+    /** A unique identifier for the widget. */
+    readonly id: Signal<string>;
+    /** The parent Toolbar UIPattern. */
+    readonly toolbar: Signal<ToolbarPattern<any>>;
+    /** A reference to the widget element to be focused on navigation. */
+    readonly element: Signal<any>;
+    /** Whether the widget is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the widget is 'hard' disabled, which is different from `aria-disabled`. A hard disabled widget cannot receive focus. */
+    readonly hardDisabled: Signal<boolean>;
+    /** The ToolbarWidget UIPattern. */
+    readonly pattern: ToolbarWidgetPattern<V>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolbarWidget<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToolbarWidget<any>, "[ngToolbarWidget]", ["ngToolbarWidget"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * A directive that groups toolbar widgets, used for more complex widgets like radio groups that
+ * have their own internal navigation.
+ */
+declare class ToolbarWidgetGroup<V> implements OnInit, OnDestroy {
+    /** A reference to the widget element. */
+    private readonly _elementRef;
+    /** The parent Toolbar. */
+    private readonly _toolbar;
+    /** A unique identifier for the widget. */
+    private readonly _generatedId;
+    /** A unique identifier for the widget. */
+    readonly id: Signal<string>;
+    /** The parent Toolbar UIPattern. */
+    readonly toolbar: Signal<ToolbarPattern<any> | undefined>;
+    /** A reference to the widget element to be focused on navigation. */
+    readonly element: Signal<any>;
+    /** Whether the widget group is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The controls that can be performed on the widget group. */
+    readonly controls: _angular_core.WritableSignal<ToolbarWidgetGroupControls | undefined>;
+    /** The ToolbarWidgetGroup UIPattern. */
+    readonly pattern: ToolbarWidgetGroupPattern<V>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolbarWidgetGroup<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToolbarWidgetGroup<any>, never, never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { Toolbar, ToolbarWidget, ToolbarWidgetGroup };