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

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 };

package/types/_tree-chunk.d.ts

@@ -0,0 +1,185 @@
+import { SignalLike, WritableSignalLike } from './_list-navigation-chunk.js';
+import { ListItem, ListInputs, List } from './_list-chunk.js';
+import { ExpansionItem, ListExpansion } from './_expansion-chunk.js';
+import { KeyboardEventManager } from './_keyboard-event-manager-chunk.js';
+import { PointerEventManager } from './_pointer-event-manager-chunk.js';
+
+/** Represents the required inputs for a tree item. */
+interface TreeItemInputs<V> extends Omit<ListItem<V>, 'index'>, Omit<ExpansionItem, 'expandable'> {
+    /** The parent item. */
+    parent: SignalLike<TreeItemPattern<V> | TreePattern<V>>;
+    /** Whether this item has children. Children can be lazily loaded. */
+    hasChildren: SignalLike<boolean>;
+    /** The children items. */
+    children: SignalLike<TreeItemPattern<V>[]>;
+    /** The tree pattern this item belongs to. */
+    tree: SignalLike<TreePattern<V>>;
+}
+/**
+ * Represents an item in a Tree.
+ */
+declare class TreeItemPattern<V> implements ListItem<V>, ExpansionItem {
+    readonly inputs: TreeItemInputs<V>;
+    /** A unique identifier for this item. */
+    readonly id: SignalLike<string>;
+    /** The value of this item. */
+    readonly value: SignalLike<V>;
+    /** A reference to the item element. */
+    readonly element: SignalLike<HTMLElement>;
+    /** Whether the item is disabled. */
+    readonly disabled: SignalLike<boolean>;
+    /** The text used by the typeahead search. */
+    readonly searchTerm: SignalLike<string>;
+    /** The tree pattern this item belongs to. */
+    readonly tree: SignalLike<TreePattern<V>>;
+    /** The parent item. */
+    readonly parent: SignalLike<TreeItemPattern<V> | TreePattern<V>>;
+    /** The children items. */
+    readonly children: SignalLike<TreeItemPattern<V>[]>;
+    /** The position of this item among its siblings. */
+    readonly index: SignalLike<number>;
+    /** Controls expansion for child items. */
+    readonly expansionBehavior: ListExpansion;
+    /** Whether the item is expandable. It's expandable if children item exist. */
+    readonly expandable: SignalLike<boolean>;
+    /** Whether the item is selectable. */
+    readonly selectable: SignalLike<boolean>;
+    /** Whether the item is expanded. */
+    readonly expanded: WritableSignalLike<boolean>;
+    /** The level of the current item in a tree. */
+    readonly level: SignalLike<number>;
+    /** Whether this item is visible. */
+    readonly visible: SignalLike<boolean>;
+    /** The number of items under the same parent at the same level. */
+    readonly setsize: SignalLike<number>;
+    /** The position of this item among its siblings (1-based). */
+    readonly posinset: SignalLike<number>;
+    /** Whether the item is active. */
+    readonly active: SignalLike<boolean>;
+    /** The tab index of the item. */
+    readonly tabIndex: SignalLike<0 | -1>;
+    /** Whether the item is selected. */
+    readonly selected: SignalLike<boolean | undefined>;
+    /** The current type of this item. */
+    readonly current: SignalLike<string | undefined>;
+    constructor(inputs: TreeItemInputs<V>);
+}
+/** The selection operations that the tree can perform. */
+interface SelectOptions {
+    toggle?: boolean;
+    selectOne?: boolean;
+    selectRange?: boolean;
+    anchor?: boolean;
+}
+/** Represents the required inputs for a tree. */
+interface TreeInputs<V> extends Omit<ListInputs<TreeItemPattern<V>, V>, 'items'> {
+    /** A unique identifier for the tree. */
+    id: SignalLike<string>;
+    /** All items in the tree, in document order (DFS-like, a flattened list). */
+    allItems: SignalLike<TreeItemPattern<V>[]>;
+    /** Whether the tree is in navigation mode. */
+    nav: SignalLike<boolean>;
+    /** The aria-current type. */
+    currentType: SignalLike<'page' | 'step' | 'location' | 'date' | 'time' | 'true' | 'false'>;
+}
+/** Controls the state and interactions of a tree view. */
+declare class TreePattern<V> implements TreeInputs<V> {
+    readonly inputs: TreeInputs<V>;
+    /** The list behavior for the tree. */
+    readonly listBehavior: List<TreeItemPattern<V>, V>;
+    /** Controls expansion for direct children of the tree root (top-level items). */
+    readonly expansionBehavior: ListExpansion;
+    /** The root level is 0. */
+    readonly level: () => number;
+    /** The root is always expanded. */
+    readonly expanded: () => boolean;
+    /** The root is always visible. */
+    readonly visible: () => boolean;
+    /** The tab index of the tree. */
+    readonly tabIndex: SignalLike<-1 | 0>;
+    /** The id of the current active item. */
+    readonly activeDescendant: SignalLike<string | undefined>;
+    /** The direct children of the root (top-level tree items). */
+    readonly children: SignalLike<TreeItemPattern<V>[]>;
+    /** All currently visible tree items. An item is visible if their parent is expanded. */
+    readonly visibleItems: SignalLike<TreeItemPattern<V>[]>;
+    /** Whether the tree selection follows focus. */
+    readonly followFocus: SignalLike<boolean>;
+    /** Whether the tree direction is RTL. */
+    readonly isRtl: SignalLike<boolean>;
+    /** The key for navigating to the previous item. */
+    readonly prevKey: SignalLike<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
+    /** The key for navigating to the next item. */
+    readonly nextKey: SignalLike<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
+    /** The key for collapsing an item or moving to its parent. */
+    readonly collapseKey: SignalLike<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
+    /** The key for expanding an item or moving to its first child. */
+    readonly expandKey: SignalLike<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
+    /** Represents the space key. Does nothing when the user is actively using typeahead. */
+    readonly dynamicSpaceKey: SignalLike<"" | " ">;
+    /** Regular expression to match characters for typeahead. */
+    readonly typeaheadRegexp: RegExp;
+    /** The keydown event manager for the tree. */
+    readonly keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
+    /** The pointerdown event manager for the tree. */
+    pointerdown: SignalLike<PointerEventManager<PointerEvent>>;
+    /** A unique identifier for the tree. */
+    readonly id: SignalLike<string>;
+    /** The host native element. */
+    readonly element: SignalLike<HTMLElement>;
+    /** Whether the tree is in navigation mode. */
+    readonly nav: SignalLike<boolean>;
+    /** The aria-current type. */
+    readonly currentType: SignalLike<'page' | 'step' | 'location' | 'date' | 'time' | 'true' | 'false'>;
+    /** All items in the tree, in document order (DFS-like, a flattened list). */
+    readonly allItems: SignalLike<TreeItemPattern<V>[]>;
+    /** The focus strategy used by the tree. */
+    readonly focusMode: SignalLike<'roving' | 'activedescendant'>;
+    /** Whether the tree is disabled. */
+    readonly disabled: SignalLike<boolean>;
+    /** The currently active item in the tree. */
+    readonly activeItem: WritableSignalLike<TreeItemPattern<V> | undefined>;
+    /** Whether disabled items should be focusable. */
+    readonly softDisabled: SignalLike<boolean>;
+    /** Whether the focus should wrap when navigating past the first or last item. */
+    readonly wrap: SignalLike<boolean>;
+    /** The orientation of the tree. */
+    readonly orientation: SignalLike<'vertical' | 'horizontal'>;
+    /** The text direction of the tree. */
+    readonly textDirection: SignalLike<'ltr' | 'rtl'>;
+    /** Whether multiple items can be selected at the same time. */
+    readonly multi: SignalLike<boolean>;
+    /** The selection mode of the tree. */
+    readonly selectionMode: SignalLike<'follow' | 'explicit'>;
+    /** The delay in milliseconds to wait before clearing the typeahead buffer. */
+    readonly typeaheadDelay: SignalLike<number>;
+    /** The current selected items of the tree. */
+    readonly values: WritableSignalLike<V[]>;
+    constructor(inputs: TreeInputs<V>);
+    /**
+     * Sets the tree to it's default initial state.
+     *
+     * Sets the active index of the tree to the first focusable selected tree item if one exists.
+     * Otherwise, sets focus to the first focusable tree item.
+     */
+    setDefaultState(): void;
+    /** Handles keydown events on the tree. */
+    onKeydown(event: KeyboardEvent): void;
+    /** Handles pointerdown events on the tree. */
+    onPointerdown(event: PointerEvent): void;
+    /** Navigates to the given tree item in the tree. */
+    goto(e: PointerEvent, opts?: SelectOptions): void;
+    /** Toggles to expand or collapse a tree item. */
+    toggleExpansion(item?: TreeItemPattern<V>): void;
+    /** Expands a tree item. */
+    expand(opts?: SelectOptions): void;
+    /** Expands all sibling tree items including itself. */
+    expandSiblings(item?: TreeItemPattern<V>): void;
+    /** Collapses a tree item. */
+    collapse(opts?: SelectOptions): void;
+    /** Retrieves the TreeItemPattern associated with a DOM event, if any. */
+    protected _getItem(event: Event): TreeItemPattern<V> | undefined;
+}
+
+export { TreeItemPattern, TreePattern };
+export type { TreeInputs, TreeItemInputs };

package/types/accordion.d.ts

@@ -1,8 +1,12 @@
 import * as _angular_core from '@angular/core';
 import { WritableSignal } from '@angular/core';
-import * as i1 from '@angular/aria/private';
-import { AccordionTriggerPattern, AccordionPanelPattern, AccordionGroupPattern } from '@angular/aria/private';
+import { AccordionTriggerPattern, AccordionPanelPattern, AccordionGroupPattern } from './_accordion-chunk.js';
+import { DeferredContentAware, DeferredContent } from './_deferred-content-chunk.js';
 import * as _angular_cdk_bidi from '@angular/cdk/bidi';
+import './_keyboard-event-manager-chunk.js';
+import './_list-navigation-chunk.js';
+import './_pointer-event-manager-chunk.js';
+import './_expansion-chunk.js';
 
 /**
  * The content panel of an accordion item that is conditionally visible.
@@ -23,6 +27,7 @@ import * as _angular_cdk_bidi from '@angular/cdk/bidi';
  * ```
  *
  * @developerPreview 21.0
+ * @see [Accordion](guide/aria/accordion)
  */
 declare class AccordionPanel {
     /** The DeferredContentAware host directive. */
@@ -45,7 +50,7 @@ declare class AccordionPanel {
     /** Toggles the expansion state of this item. */
     toggle(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionPanel, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionPanel, "[ngAccordionPanel]", ["ngAccordionPanel"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "panelId": { "alias": "panelId"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.DeferredContentAware; inputs: { "preserveContent": "preserveContent"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionPanel, "[ngAccordionPanel]", ["ngAccordionPanel"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "panelId": { "alias": "panelId"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof DeferredContentAware; inputs: { "preserveContent": "preserveContent"; }; outputs: {}; }]>;
 }
 
 /**
@@ -82,6 +87,7 @@ declare class AccordionPanel {
  * ```
  *
  * @developerPreview 21.0
+ * @see [Accordion](guide/aria/accordion)
  */
 declare class AccordionGroup {
     /** A reference to the group element. */
@@ -136,6 +142,7 @@ declare class AccordionGroup {
  * ```
  *
  * @developerPreview 21.0
+ * @see [Accordion](guide/aria/accordion)
  */
 declare class AccordionTrigger {
     /** A reference to the trigger element. */
@@ -185,10 +192,11 @@ declare class AccordionTrigger {
  * ```
  *
  * @developerPreview 21.0
+ * @see [Accordion](guide/aria/accordion)
  */
 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: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionContent, "ng-template[ngAccordionContent]", never, {}, {}, never, never, true, [{ directive: typeof DeferredContent; inputs: {}; outputs: {}; }]>;
 }
 
-export { AccordionContent, AccordionGroup, AccordionPanel, AccordionTrigger };
+export { AccordionContent, AccordionGroup, AccordionPanel, AccordionTrigger, DeferredContent as ɵɵDeferredContent };

package/types/aria.d.ts

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