@angular/aria 0.0.1 → 21.0.0-next.10

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

package/types/tree.d.ts

@@ -0,0 +1,135 @@
+import * as _angular_cdk_bidi from '@angular/cdk/bidi';
+import * as _angular_core from '@angular/core';
+import { Signal, OnInit, OnDestroy } from '@angular/core';
+import * as i1 from '@angular/aria/deferred-content';
+import { DeferredContentAware } from '@angular/aria/deferred-content';
+import { TreePattern, TreeItemPattern } from '@angular/aria/ui-patterns';
+import { ComboboxPopup } from './combobox.js';
+
+interface HasElement {
+    element: Signal<HTMLElement>;
+}
+/**
+ * A Tree container.
+ *
+ * Transforms nested lists into an accessible, ARIA-compliant tree structure.
+ *
+ * ```html
+ * <ul ngTree [(value)]="selectedItems" [multi]="true">
+ *   <li ngTreeItem [value]="'leaf1'">Leaf Item 1</li>
+ *   <li ngTreeItem [value]="'parent1'">
+ *     Parent Item 1
+ *     <ul ngTreeItemGroup [value]="'parent1'">
+ *       <ng-template ngTreeItemGroupContent>
+ *         <li ngTreeItem [value]="'child1.1'">Child Item 1.1</li>
+ *         <li ngTreeItem [value]="'child1.2'">Child Item 1.2</li>
+ *       </ng-template>
+ *     </ul>
+ *   </li>
+ *   <li ngTreeItem [value]="'leaf2'" [disabled]="true">Disabled Leaf Item 2</li>
+ * </ul>
+ * ```
+ */
+declare class Tree<V> {
+    /** A unique identifier for the tree. */
+    private readonly _generatedId;
+    /** A unique identifier for the tree. */
+    protected id: Signal<string>;
+    /** A reference to the parent combobox popup, if one exists. */
+    private readonly _popup;
+    /** A reference to the tree element. */
+    private readonly _elementRef;
+    /** All TreeItem instances within this tree. */
+    private readonly _unorderedItems;
+    /** Orientation of the tree. */
+    readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    /** Whether multi-selection is allowed. */
+    readonly multi: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the tree is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The selection strategy used by the tree. */
+    readonly selectionMode: _angular_core.InputSignal<"explicit" | "follow">;
+    /** The focus strategy used by the tree. */
+    readonly focusMode: _angular_core.InputSignal<"roving" | "activedescendant">;
+    /** Whether navigation wraps. */
+    readonly wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether to skip disabled items during navigation. */
+    readonly skipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Typeahead delay. */
+    readonly typeaheadDelay: _angular_core.InputSignal<number>;
+    /** Selected item values. */
+    readonly value: _angular_core.ModelSignal<V[]>;
+    /** Text direction. */
+    readonly textDirection: _angular_core.WritableSignal<_angular_cdk_bidi.Direction>;
+    /** Whether the tree is in navigation mode. */
+    readonly nav: _angular_core.InputSignal<boolean>;
+    /** The aria-current type. */
+    readonly currentType: _angular_core.InputSignal<"page" | "step" | "location" | "date" | "time" | "true" | "false">;
+    /** The UI pattern for the tree. */
+    readonly pattern: TreePattern<V>;
+    /** Whether the tree has received focus yet. */
+    private _hasFocused;
+    constructor();
+    onFocus(): void;
+    register(child: TreeItem<V>): void;
+    unregister(child: TreeItem<V>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tree<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Tree<any>, "[ngTree]", ["ngTree"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "focusMode": { "alias": "focusMode"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "skipDisabled": { "alias": "skipDisabled"; "required": false; "isSignal": true; }; "typeaheadDelay": { "alias": "typeaheadDelay"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "nav": { "alias": "nav"; "required": false; "isSignal": true; }; "currentType": { "alias": "currentType"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, [{ directive: typeof ComboboxPopup; inputs: {}; outputs: {}; }]>;
+}
+/**
+ * A selectable and expandable Tree Item in a Tree.
+ */
+declare class TreeItem<V> extends DeferredContentAware implements OnInit, OnDestroy, HasElement {
+    /** A reference to the tree item element. */
+    private readonly _elementRef;
+    /** A unique identifier for the tree item. */
+    private readonly _id;
+    /** The owned tree item group. */
+    private readonly _group;
+    /** The host native element. */
+    readonly element: Signal<any>;
+    /** The value of the tree item. */
+    readonly value: _angular_core.InputSignal<V>;
+    /** The parent tree root or tree item group. */
+    readonly parent: _angular_core.InputSignal<TreeItemGroup<V> | Tree<V>>;
+    /** Whether the tree item is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the tree item is selectable. */
+    readonly selectable: _angular_core.InputSignal<boolean>;
+    /** Optional label for typeahead. Defaults to the element's textContent. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Search term for typeahead. */
+    readonly searchTerm: Signal<any>;
+    /** The tree root. */
+    readonly tree: Signal<Tree<V>>;
+    /** The UI pattern for this item. */
+    pattern: TreeItemPattern<V>;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    register(group: TreeItemGroup<V>): void;
+    unregister(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeItem<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeItem<any>, "[ngTreeItem]", ["ngTreeItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "parent": { "alias": "parent"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Contains children tree itmes.
+ */
+declare class TreeItemGroup<V> implements OnInit, OnDestroy {
+    /** The DeferredContent host directive. */
+    private readonly _deferredContent;
+    /** All groupable items that are descendants of the group. */
+    private readonly _unorderedItems;
+    /** Child items within this group. */
+    readonly children: Signal<TreeItemPattern<V>[]>;
+    /** Tree item that owns the group. */
+    readonly ownedBy: _angular_core.InputSignal<TreeItem<V>>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    register(child: TreeItem<V>): void;
+    unregister(child: TreeItem<V>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeItemGroup<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeItemGroup<any>, "ng-template[ngTreeItemGroup]", ["ngTreeItemGroup"], { "ownedBy": { "alias": "ownedBy"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.DeferredContent; inputs: {}; outputs: {}; }]>;
+}
+
+export { Tree, TreeItem, TreeItemGroup };