@angular/aria 0.0.1 → 21.0.0-next.10

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,60 @@
+import * as _angular_core from '@angular/core';
+import { WritableSignal } from '@angular/core';
+import * as _angular_cdk_bidi from '@angular/cdk/bidi';
+import { ComboboxPattern, ComboboxListboxControls, ComboboxTreeControls } from '@angular/aria/ui-patterns';
+import * as i1 from '@angular/aria/deferred-content';
+
+declare class Combobox<V> {
+    /** The directionality (LTR / RTL) context for the application (or a subtree of it). */
+    private readonly _directionality;
+    /** A signal wrapper for directionality. */
+    protected textDirection: _angular_core.Signal<_angular_cdk_bidi.Direction>;
+    /** 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>;
+    /** Whether the listbox has received focus yet. */
+    private _hasBeenFocused;
+    /** Whether the combobox is disabled. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Whether the combobox is read-only. */
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    /** The value of the first matching item in the popup. */
+    readonly firstMatch: _angular_core.InputSignal<V | undefined>;
+    /** 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; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "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/grid.d.ts

@@ -0,0 +1,111 @@
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+import { GridPattern, GridRowPattern, GridCellPattern, GridCellWidgetPattern } from './_grid-chunk.js';
+
+/** A directive that provides grid-based navigation and selection behavior. */
+declare class Grid {
+    /** A reference to the host element. */
+    private readonly _elementRef;
+    /** The rows that make up the grid. */
+    private readonly _rows;
+    /** The UI patterns for the rows in the grid. */
+    private readonly _rowPatterns;
+    /** The host native element. */
+    readonly element: Signal<any>;
+    /** Whether selection is enabled for the grid. */
+    readonly enableSelection: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the grid is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether to skip disabled items during navigation. */
+    readonly skipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The focus strategy used by the grid. */
+    readonly focusMode: _angular_core.InputSignal<"roving" | "activedescendant">;
+    /** The wrapping behavior for keyboard navigation along the row axis. */
+    readonly rowWrap: _angular_core.InputSignal<"continuous" | "loop" | "nowrap">;
+    /** The wrapping behavior for keyboard navigation along the column axis. */
+    readonly colWrap: _angular_core.InputSignal<"continuous" | "loop" | "nowrap">;
+    /** The UI pattern for the grid. */
+    readonly pattern: GridPattern;
+    constructor();
+    /** Gets the cell pattern for a given element. */
+    private _getCell;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Grid, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Grid, "[ngGrid]", ["ngGrid"], { "enableSelection": { "alias": "enableSelection"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "skipDisabled": { "alias": "skipDisabled"; "required": false; "isSignal": true; }; "focusMode": { "alias": "focusMode"; "required": false; "isSignal": true; }; "rowWrap": { "alias": "rowWrap"; "required": false; "isSignal": true; }; "colWrap": { "alias": "colWrap"; "required": false; "isSignal": true; }; }, {}, ["_rows"], never, true, never>;
+}
+/** A directive that represents a row in a grid. */
+declare class GridRow {
+    /** A reference to the host element. */
+    private readonly _elementRef;
+    /** The cells that make up this row. */
+    private readonly _cells;
+    /** The UI patterns for the cells in this row. */
+    private readonly _cellPatterns;
+    /** The parent grid. */
+    private readonly _grid;
+    /** The parent grid UI pattern. */
+    readonly grid: Signal<GridPattern>;
+    /** The host native element. */
+    readonly element: Signal<any>;
+    /** The ARIA role for the row. */
+    readonly role: _angular_core.InputSignal<"row" | "rowheader">;
+    /** The index of this row within the grid. */
+    readonly rowIndex: _angular_core.InputSignal<number | undefined>;
+    /** The UI pattern for the grid row. */
+    readonly pattern: GridRowPattern;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridRow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridRow, "[ngGridRow]", ["ngGridRow"], { "role": { "alias": "role"; "required": false; "isSignal": true; }; "rowIndex": { "alias": "rowIndex"; "required": false; "isSignal": true; }; }, {}, ["_cells"], never, true, never>;
+}
+/** A directive that represents a cell in a grid. */
+declare class GridCell {
+    /** A reference to the host element. */
+    private readonly _elementRef;
+    /** The widget contained within this cell, if any. */
+    private readonly _widgets;
+    /** The UI pattern for the widget in this cell. */
+    private readonly _widgetPattern;
+    /** The parent row. */
+    private readonly _row;
+    /** A unique identifier for the cell. */
+    private readonly _id;
+    /** The host native element. */
+    readonly element: Signal<any>;
+    /** The ARIA role for the cell. */
+    readonly role: _angular_core.InputSignal<"gridcell" | "columnheader">;
+    /** The number of rows the cell should span. */
+    readonly rowSpan: _angular_core.InputSignal<number>;
+    /** The number of columns the cell should span. */
+    readonly colSpan: _angular_core.InputSignal<number>;
+    /** The index of this cell's row within the grid. */
+    readonly rowIndex: _angular_core.InputSignal<number | undefined>;
+    /** The index of this cell's column within the grid. */
+    readonly colIndex: _angular_core.InputSignal<number | undefined>;
+    /** Whether the cell is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the cell is selected. */
+    readonly selected: _angular_core.ModelSignal<boolean>;
+    /** Whether the cell is selectable. */
+    readonly selectable: _angular_core.InputSignal<boolean>;
+    /** The UI pattern for the grid cell. */
+    readonly pattern: GridCellPattern;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridCell, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridCell, "[ngGridCell]", ["ngGridCell"], { "role": { "alias": "role"; "required": false; "isSignal": true; }; "rowSpan": { "alias": "rowSpan"; "required": false; "isSignal": true; }; "colSpan": { "alias": "colSpan"; "required": false; "isSignal": true; }; "rowIndex": { "alias": "rowIndex"; "required": false; "isSignal": true; }; "colIndex": { "alias": "colIndex"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; }, ["_widgets"], never, true, never>;
+}
+/** A directive that represents a widget inside a grid cell. */
+declare class GridCellWidget {
+    /** A reference to the host element. */
+    private readonly _elementRef;
+    /** The parent cell. */
+    private readonly _cell;
+    /** The host native element. */
+    readonly element: Signal<any>;
+    /** Whether the widget is activated and the grid navigation should be paused. */
+    readonly activate: _angular_core.ModelSignal<boolean>;
+    /** The UI pattern for the grid cell widget. */
+    readonly pattern: GridCellWidgetPattern;
+    /** Focuses the widget. */
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridCellWidget, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridCellWidget, "[ngGridCellWidget]", ["ngGridCellWidget"], { "activate": { "alias": "activate"; "required": false; "isSignal": true; }; }, { "activate": "activateChange"; }, never, never, true, never>;
+}
+
+export { Grid, GridCell, GridCellWidget, GridRow };

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/menu.d.ts

@@ -0,0 +1,158 @@
+import * as _angular_cdk_bidi from '@angular/cdk/bidi';
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+import { MenuTriggerPattern, MenuPattern, MenuItemPattern, SignalLike, MenuBarPattern } from '@angular/aria/ui-patterns';
+
+/**
+ * A trigger for a menu.
+ *
+ * The menu trigger is used to open and close menus, and can be placed on menu items to connect
+ * sub-menus.
+ */
+declare class MenuTrigger<V> {
+    /** A reference to the menu trigger element. */
+    private readonly _elementRef;
+    /** A reference to the menu element. */
+    readonly element: HTMLButtonElement;
+    /** The submenu associated with the menu trigger. */
+    submenu: _angular_core.InputSignal<Menu<V> | undefined>;
+    /** A callback function triggered when a menu item is selected. */
+    onSubmit: _angular_core.OutputEmitterRef<V>;
+    /** The menu trigger ui pattern instance. */
+    uiPattern: MenuTriggerPattern<V>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuTrigger<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuTrigger<any>, "button[ngMenuTrigger]", ["ngMenuTrigger"], { "submenu": { "alias": "submenu"; "required": false; "isSignal": true; }; }, { "onSubmit": "onSubmit"; }, never, never, true, never>;
+}
+/**
+ * A list of menu items.
+ *
+ * A menu is used to offer a list of menu item choices to users. Menus can be nested within other
+ * menus to create sub-menus.
+ *
+ * ```html
+ * <button ngMenuTrigger menu="menu">Options</button>
+ *
+ * <div ngMenu #menu="ngMenu">
+ *   <div ngMenuItem>Star</div>
+ *   <div ngMenuItem>Edit</div>
+ *   <div ngMenuItem>Delete</div>
+ * </div>
+ * ```
+ */
+declare class Menu<V> {
+    /** The menu items contained in the menu. */
+    readonly _allItems: Signal<readonly MenuItem<V>[]>;
+    /** The menu items that are direct children of this menu. */
+    readonly _items: Signal<MenuItem<V>[]>;
+    /** A reference to the menu element. */
+    private readonly _elementRef;
+    /** A reference to the menu element. */
+    readonly element: HTMLElement;
+    /** The directionality (LTR / RTL) context for the application (or a subtree of it). */
+    private readonly _directionality;
+    /** A signal wrapper for directionality. */
+    readonly textDirection: Signal<_angular_cdk_bidi.Direction>;
+    /** The submenu associated with the menu. */
+    readonly submenu: _angular_core.InputSignal<Menu<V> | undefined>;
+    /** The unique ID of the menu. */
+    readonly id: _angular_core.InputSignal<string>;
+    /** Whether the menu should wrap its items. */
+    readonly wrap: _angular_core.InputSignal<boolean>;
+    /** The delay in seconds before the typeahead buffer is cleared. */
+    readonly typeaheadDelay: _angular_core.InputSignal<number>;
+    /** A reference to the parent menu item or menu trigger. */
+    readonly parent: _angular_core.InputSignal<MenuItem<V> | MenuTrigger<V> | undefined>;
+    /** The menu ui pattern instance. */
+    readonly uiPattern: MenuPattern<V>;
+    /**
+     * The menu items as a writable signal.
+     *
+     * TODO(wagnermaciel): This would normally be a computed, but using a computed causes a bug where
+     * sometimes the items array is empty. The bug can be reproduced by switching this to use a
+     * computed and then quickly opening and closing menus in the dev app.
+     */
+    readonly items: () => MenuItemPattern<V>[];
+    /** Whether the menu is visible. */
+    isVisible: Signal<boolean>;
+    /** A callback function triggered when a menu item is selected. */
+    onSubmit: _angular_core.OutputEmitterRef<V>;
+    constructor();
+    /** Closes the menu. */
+    close(opts?: {
+        refocus?: boolean;
+    }): void;
+    /** Closes all parent menus. */
+    closeAll(opts?: {
+        refocus?: boolean;
+    }): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Menu<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Menu<any>, "[ngMenu]", ["ngMenu"], { "submenu": { "alias": "submenu"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "typeaheadDelay": { "alias": "typeaheadDelay"; "required": false; "isSignal": true; }; "parent": { "alias": "parent"; "required": false; "isSignal": true; }; }, { "onSubmit": "onSubmit"; }, ["_allItems"], never, true, never>;
+}
+/**
+ * A menu bar of menu items.
+ *
+ * Like the menu, a menubar is used to offer a list of menu item choices to users. However, a
+ * menubar is used to display a persistent, top-level,
+ * always-visible set of menu item choices.
+ */
+declare class MenuBar<V> {
+    /** The menu items contained in the menubar. */
+    readonly _allItems: Signal<readonly MenuItem<V>[]>;
+    readonly _items: SignalLike<MenuItem<V>[]>;
+    /** A reference to the menu element. */
+    private readonly _elementRef;
+    /** A reference to the menubar element. */
+    readonly element: HTMLElement;
+    /** The directionality (LTR / RTL) context for the application (or a subtree of it). */
+    private readonly _directionality;
+    /** A signal wrapper for directionality. */
+    readonly textDirection: Signal<_angular_cdk_bidi.Direction>;
+    /** The value of the menu. */
+    readonly value: _angular_core.ModelSignal<V[]>;
+    /** Whether the menu should wrap its items. */
+    readonly wrap: _angular_core.InputSignal<boolean>;
+    /** The delay in seconds before the typeahead buffer is cleared. */
+    readonly typeaheadDelay: _angular_core.InputSignal<number>;
+    /** The menu ui pattern instance. */
+    readonly uiPattern: MenuBarPattern<V>;
+    /** The menu items as a writable signal. */
+    readonly items: _angular_core.WritableSignal<MenuItemPattern<V>[]>;
+    /** A callback function triggered when a menu item is selected. */
+    onSubmit: _angular_core.OutputEmitterRef<V>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuBar<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuBar<any>, "[ngMenuBar]", ["ngMenuBar"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "typeaheadDelay": { "alias": "typeaheadDelay"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onSubmit": "onSubmit"; }, ["_allItems"], never, true, never>;
+}
+/**
+ * An item in a Menu.
+ *
+ * Menu items can be used in menus and menubars to represent a choice or action a user can take.
+ */
+declare class MenuItem<V> {
+    /** A reference to the menu item element. */
+    private readonly _elementRef;
+    /** A reference to the menu element. */
+    readonly element: HTMLElement;
+    /** The unique ID of the menu item. */
+    readonly id: _angular_core.InputSignal<string>;
+    /** The value of the menu item. */
+    readonly value: _angular_core.InputSignal<V>;
+    /** Whether the menu item is disabled. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** The search term associated with the menu item. */
+    readonly searchTerm: _angular_core.ModelSignal<string>;
+    /** A reference to the parent menu. */
+    private readonly _menu;
+    /** A reference to the parent menu bar. */
+    private readonly _menuBar;
+    /** A reference to the parent menu or menubar. */
+    readonly parent: Menu<V> | MenuBar<V> | null;
+    /** The submenu associated with the menu item. */
+    readonly submenu: _angular_core.InputSignal<Menu<V> | undefined>;
+    /** The menu item ui pattern instance. */
+    readonly uiPattern: MenuItemPattern<V>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItem<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuItem<any>, "[ngMenuItem]", ["ngMenuItem"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "searchTerm": { "alias": "searchTerm"; "required": false; "isSignal": true; }; "submenu": { "alias": "submenu"; "required": false; "isSignal": true; }; }, { "searchTerm": "searchTermChange"; }, never, never, true, never>;
+}
+
+export { Menu, MenuBar, MenuItem, MenuTrigger };