@ngneers/controls 0.0.1-next.0

package/types/ngneers-controls-tooltip.d.ts

@@ -0,0 +1,189 @@
+import * as _ngneers_controls_api_ng from '@ngneers/controls/api/ng';
+import { PositioningSizeConstraints, TooltipOptions } from '@ngneers/controls/api/ng';
+import * as _ngneers_controls_themes from '@ngneers/controls-themes';
+import * as _angular_core from '@angular/core';
+import { OnDestroy, TemplateRef } from '@angular/core';
+import { NgnBase } from '@ngneers/controls/base';
+import { TimeSpan } from '@ngneers/controls/utils';
+import { Placement } from '@floating-ui/dom';
+
+type RelativeAnchorElementPositionData = {
+    start: number;
+    center: number;
+    end: number;
+};
+
+/**
+ * @category control
+ */
+declare class NgnTooltip extends NgnBase<'tooltip'> implements OnDestroy {
+    protected readonly theme: null;
+    private readonly _viewContainerRef;
+    private readonly _config;
+    private readonly _tooltip;
+    /**
+     * The content of the tooltip, can be a string or a TemplateRef.
+     * If the value is falsy, the tooltip will not be shown.
+     * @alias ngnTooltip
+     */
+    readonly content: _angular_core.InputSignal<string | TemplateRef<unknown> | null | undefined>;
+    /**
+     * If set to `true`, the tooltip will only be shown if the anchor element is truncated. `""` is equivalent to `true`.
+     * @alias ngnTooltipShowOnlyIfTruncated
+     * @default false
+     */
+    readonly showOnlyIfTruncated: _angular_core.InputSignal<boolean | "">;
+    /**
+     * The size constraints for the tooltip.
+     * This can be used to limit the width and height of the tooltip.
+     * If not provided, the tooltip is only constrained by the size of the screen.
+     * @alias ngnTooltipSize
+     */
+    readonly size: _angular_core.InputSignal<PositioningSizeConstraints | null | undefined>;
+    /**
+     * The options for the tooltip.
+     * This is a shorthand for setting multiple options at once.
+     * The individual options take precedence over the options set here.
+     * @alias ngnTooltipOptions
+     */
+    readonly options: _angular_core.InputSignal<Partial<TooltipOptions> | null | undefined>;
+    /**
+     * The placement of the tooltip relative to the anchor element.
+     * @alias ngnTooltipPlacement
+     * @default 'bottom'
+     */
+    readonly placement: _angular_core.InputSignal<Placement | null | undefined>;
+    /**
+     * The offset in Pixels of the tooltip from the anchor element.
+     * @alias ngnTooltipOffset
+     * @default 4
+     */
+    readonly offset: _angular_core.InputSignal<number | null | undefined>;
+    /**
+     * The delay before the tooltip is shown. If a number is provided, it is interpreted as milliseconds.
+     * @alias ngnTooltipShowDelay
+     * @default '0.5s'
+     */
+    readonly showDelay: _angular_core.InputSignal<TimeSpan | null | undefined>;
+    /**
+     * The delay before the tooltip is hidden. If a number is provided, it is interpreted as milliseconds.
+     * @alias ngnTooltipHideDelay
+     * @default '0.1s'
+     */
+    readonly hideDelay: _angular_core.InputSignal<TimeSpan | null | undefined>;
+    /**
+     * Whether to show an arrow pointing to the anchor element. `""` is equivalent to `true`.
+     * @alias ngnTooltipShowArrow
+     * @default true
+     */
+    readonly showArrow: _angular_core.InputSignal<boolean | "" | null | undefined>;
+    /**
+     * Shows the tooltip on hover.
+     * @alias ngnTooltipShowOnHover
+     * @default true
+     */
+    readonly showOnHover: _angular_core.InputSignal<boolean | "" | null | undefined>;
+    /**
+     * Shows the tooltip on focus.
+     * @alias ngnTooltipShowOnFocus
+     * @default true
+     */
+    readonly showOnFocus: _angular_core.InputSignal<boolean | "" | null | undefined>;
+    /**
+     * Hides the tooltip (without delay) when the mouse hovers over the tooltip.
+     * @alias ngnTooltipHideOnTooltipHover
+     * @default false
+     */
+    readonly hideOnTooltipHover: _angular_core.InputSignal<boolean | "" | null | undefined>;
+    /**
+     * Hides the tooltip (without delay) when the user clicks on the tooltip.
+     * @alias ngnTooltipHideOnClick
+     * @default true
+     */
+    readonly hideOnClick: _angular_core.InputSignal<boolean | "" | null | undefined>;
+    /**
+     * Whether to automatically manage ARIA attributes for the tooltip.
+     * @alias ngnTooltipAutoAriaMode
+     * @default 'description'
+     */
+    readonly autoAriaMode: _angular_core.InputSignal<"label" | "description" | "none" | null | undefined>;
+    readonly effectiveOptions: _angular_core.Signal<TooltipOptions>;
+    readonly tooltip: _angular_core.Signal<TooltipComponent | undefined>;
+    constructor();
+    ngOnDestroy(): void;
+    show(): void;
+    hide(): void;
+    protected onMouseEnter(): void;
+    protected onMouseLeave(): void;
+    protected onFocus(): void;
+    protected onBlur(): void;
+    private getTooltip;
+    private updateContent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgnTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgnTooltip, "[ngnTooltip]", ["ngnTooltip"], { "content": { "alias": "ngnTooltip"; "required": false; "isSignal": true; }; "showOnlyIfTruncated": { "alias": "ngnTooltipShowOnlyIfTruncated"; "required": false; "isSignal": true; }; "size": { "alias": "ngnTooltipSize"; "required": false; "isSignal": true; }; "options": { "alias": "ngnTooltipOptions"; "required": false; "isSignal": true; }; "placement": { "alias": "ngnTooltipPlacement"; "required": false; "isSignal": true; }; "offset": { "alias": "ngnTooltipOffset"; "required": false; "isSignal": true; }; "showDelay": { "alias": "ngnTooltipShowDelay"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "ngnTooltipHideDelay"; "required": false; "isSignal": true; }; "showArrow": { "alias": "ngnTooltipShowArrow"; "required": false; "isSignal": true; }; "showOnHover": { "alias": "ngnTooltipShowOnHover"; "required": false; "isSignal": true; }; "showOnFocus": { "alias": "ngnTooltipShowOnFocus"; "required": false; "isSignal": true; }; "hideOnTooltipHover": { "alias": "ngnTooltipHideOnTooltipHover"; "required": false; "isSignal": true; }; "hideOnClick": { "alias": "ngnTooltipHideOnClick"; "required": false; "isSignal": true; }; "autoAriaMode": { "alias": "ngnTooltipAutoAriaMode"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class TooltipComponent extends NgnBase<'tooltip'> {
+    private _showHideTimeout?;
+    protected readonly theme: _ngneers_controls_api_ng.ControlTemplateInfo<_ngneers_controls_themes.ControlTemplate<"tooltip", ["root", "content", "text", "with-arrow", "closing", "fade-in", "fade-out", "top", "bottom", "left", "right", "start", "end"], readonly []>>;
+    private readonly _config;
+    /**
+     * The anchor element to which the tooltip is attached.
+     */
+    readonly anchor: _angular_core.InputSignal<HTMLElement>;
+    /**
+     * The text content of the tooltip.
+     */
+    readonly text: _angular_core.InputSignal<string | null | undefined>;
+    /**
+     * The content template of the tooltip.
+     */
+    readonly content: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
+    /**
+     * If set to `true`, the tooltip will only be shown if the anchor element is truncated. `""` is equivalent to `true`.
+     * @default `false`
+     */
+    readonly showOnlyIfTruncated: _angular_core.InputSignal<boolean | "">;
+    /**
+     * The size constraints for the tooltip.
+     * This can be used to limit the width and height of the tooltip.
+     * If not provided, the tooltip is only constrained by the size of the screen.
+     */
+    readonly size: _angular_core.InputSignal<PositioningSizeConstraints | null | undefined>;
+    /**
+     * The options for the tooltip.
+     *
+     */
+    readonly options: _angular_core.InputSignal<TooltipOptions>;
+    protected readonly showDelayMs: _angular_core.Signal<number>;
+    protected readonly hideDelayMs: _angular_core.Signal<number>;
+    protected readonly position: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+    }>;
+    protected readonly positionClass: _angular_core.WritableSignal<string>;
+    protected readonly relativeAnchorElementPosition: _angular_core.WritableSignal<RelativeAnchorElementPositionData | undefined>;
+    private readonly _isShown;
+    private readonly _isClosing;
+    readonly id: string;
+    readonly isShown: _angular_core.Signal<boolean>;
+    readonly isClosing: _angular_core.Signal<boolean>;
+    private readonly _defaultContentTemplate;
+    protected readonly contentTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    private readonly _autoPos;
+    private readonly onDocumentKeyDownBound;
+    constructor();
+    show(skipDelay?: boolean): void;
+    hide(skipDelay?: boolean): void;
+    protected onMouseEnter(): void;
+    protected onMouseLeave(): void;
+    protected onClick(event: PointerEvent): void;
+    protected onDocumentKeyDown(event: KeyboardEvent): void;
+    protected onShow(): void;
+    protected onHide(): void;
+    protected onToggle(event: Event): void;
+    protected toPixels(value: number | undefined): string | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TooltipComponent, "ngn-tooltip", never, { "anchor": { "alias": "anchor"; "required": true; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "showOnlyIfTruncated": { "alias": "showOnlyIfTruncated"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NgnTooltip, TooltipComponent };

package/types/ngneers-controls-tree.d.ts

@@ -0,0 +1,409 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, OnInit } from '@angular/core';
+import * as _ngneers_controls_api_ng from '@ngneers/controls/api/ng';
+import { NgnStorageKind } from '@ngneers/controls/api/ng';
+import * as _ngneers_controls_themes from '@ngneers/controls-themes';
+import * as _ngneers_signal_translate from '@ngneers/signal-translate';
+import { NgnTreeItem, NgnTreeItemsValue, FilterConfig } from '@ngneers/controls/api';
+import { InputGeneric, maybeCallback } from '@ngneers/controls/utils';
+import { ValueControlBase } from '@ngneers/controls/base';
+
+/**
+ * Value type for the tree control.
+ * * When `multiple` is `true`, the value is an array of node values.
+ * * Otherwise it is a single node value.
+ *
+ * Uses {@link NgnTreeItemsValue} (branch + leaf values) rather than the
+ * leaf-only `NgnItemsValue`, since a branch node can be selected too.
+ */
+type ValueType<Items extends readonly NgnTreeItem[], Multiple extends boolean> = InputGeneric<Multiple, false> extends true ? NgnTreeItemsValue<Items>[] : NgnTreeItemsValue<Items>;
+declare abstract class TreeTemplates<Items extends readonly NgnTreeItem[], Multiple extends boolean> extends ValueControlBase<'tree', ValueType<Items, Multiple> | null> {
+    private readonly _defaultItemTemplate;
+    private readonly _userItemTemplate;
+    /**
+     * Set a custom template for a tree node.
+     * Can also be set via an `<ng-template #item>` element. A per-node
+     * `item.template` takes precedence over this global template.
+     */
+    readonly templateItem: _angular_core.InputSignal<TemplateRef<{
+        $implicit: Items[number] | undefined;
+        level: number;
+        expanded: boolean;
+        hasChildren: boolean;
+    }> | null>;
+    protected readonly itemTemplate: _angular_core.Signal<TemplateRef<{
+        $implicit: Items[number] | undefined;
+        level: number;
+        expanded: boolean;
+        hasChildren: boolean;
+    }>>;
+    private readonly _defaultEmptyTemplate;
+    private readonly _userEmptyTemplate;
+    /**
+     * Set a custom template for the empty state.
+     * Can also be set via an `<ng-template #empty>` element.
+     */
+    readonly templateEmpty: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    protected readonly emptyTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    readonly templateTypes: {
+        item: {
+            $implicit: Items[number] | undefined;
+            level: number;
+            expanded: boolean;
+            hasChildren: boolean;
+        };
+    } & {
+        $implicit: {
+            item: Partial<{
+                $implicit: Items[number] | undefined;
+                level: number;
+                expanded: boolean;
+                hasChildren: boolean;
+            }>;
+        };
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeTemplates<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeTemplates<any, any>, never, never, { "templateItem": { "alias": "templateItem"; "required": false; "isSignal": true; }; "templateEmpty": { "alias": "templateEmpty"; "required": false; "isSignal": true; }; }, {}, ["_userItemTemplate", "_userEmptyTemplate"], never, true, never>;
+}
+
+interface FlatTreeNode<T = any, V = any> {
+    item: NgnTreeItem<T, V>;
+    /** 0-based depth. */
+    level: number;
+    /** Number of siblings at this level (aria-setsize). */
+    setSize: number;
+    /** 1-based position among siblings (aria-posinset). */
+    posInSet: number;
+    hasChildren: boolean;
+    expanded: boolean;
+    /** True when an ancestor is disabled (disable cascades to the subtree). */
+    parentDisabled: boolean;
+}
+/** Walk the tree, emitting only expanded + visible nodes as a flat list. */
+declare function flattenTree<T, V>(items: readonly NgnTreeItem<T, V>[], expanded: ReadonlySet<V>, level?: number, parentDisabled?: boolean): FlatTreeNode<T, V>[];
+/**
+ * Inject lazily-loaded children (keyed by node value) into the tree, returning
+ * a new forest where resolved lazy nodes carry their loaded `items` and are no
+ * longer marked `lazy`. Returns the input unchanged when nothing is loaded.
+ */
+declare function applyLoadedChildren<T, V>(items: readonly NgnTreeItem<T, V>[], loaded: ReadonlyMap<V, readonly NgnTreeItem<T, V>[]>): readonly NgnTreeItem<T, V>[];
+/** All selectable, enabled leaf values under (and including) an item. */
+declare function collectLeafValues<T, V>(item: NgnTreeItem<T, V>, parentDisabled?: boolean): V[];
+/** All branch values in the forest (used to auto-expand while filtering). */
+declare function collectBranchValues<T, V>(items: readonly NgnTreeItem<T, V>[]): V[];
+/** Add/remove all of a node's enabled leaf values against the current value set. */
+declare function cascadeCheck<T, V>(node: NgnTreeItem<T, V>, shouldCheck: boolean, currentValue: readonly V[]): V[];
+/** Derive a node's tri-state from which of its leaves are in the value set. */
+declare function computeNodeState<T, V>(item: NgnTreeItem<T, V>, valueSet: ReadonlySet<V>): 'checked' | 'unchecked' | 'indeterminate';
+
+/** The individual pieces of tree state that can be persisted. */
+type NgnTreeStorageState = 'value' | 'expanded';
+/**
+ * Configuration for persisting tree state (expansion + selection).
+ * Pass to the `storage` input, e.g. `{ key: 'my-tree' }` or
+ * `{ key: 'my-tree', kind: 'sessionstorage' }`.
+ */
+interface NgnTreeStorageConfig {
+    /** The storage key under which the state is saved. */
+    key: string;
+    /**
+     * Where/how to persist. Accepts `'localstorage'`, `'sessionstorage'`, or a
+     * custom `{ initialize, update }` adapter. Defaults to `'localstorage'`.
+     */
+    kind?: NgnStorageKind<Record<string, unknown>>;
+    /**
+     * Which states to persist. When omitted, all states are saved. When
+     * provided, only the listed states are saved/restored.
+     */
+    states?: NgnTreeStorageState[];
+}
+/**
+ * @category control
+ */
+declare class NgnTree<Items extends readonly NgnTreeItem[], Multiple extends boolean = false> extends TreeTemplates<Items, Multiple> implements OnInit {
+    protected readonly i18n: _ngneers_signal_translate.TranslationsSignal<{
+        calendar: {
+            today: string;
+            input: string;
+            selectYear: string;
+            selectMonth: string;
+            previousMonth: string;
+            nextMonth: string;
+            weekdays: {
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+                sunday: string;
+            };
+            weekdaysShort: {
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+                sunday: string;
+            };
+            months: {
+                january: string;
+                february: string;
+                march: string;
+                april: string;
+                may: string;
+                june: string;
+                july: string;
+                august: string;
+                september: string;
+                october: string;
+                november: string;
+                december: string;
+            };
+        };
+        editInplace: {
+            placeholder: string;
+            confirm: string;
+        };
+        filter: {
+            noFilter: string;
+            addCondition: string;
+            removeCondition: string;
+            operator: string;
+            value: string;
+            clear: string;
+            apply: string;
+            cancel: string;
+            matchModeLabel: string;
+            match: {
+                all: string;
+                any: string;
+                and: string;
+                or: string;
+            };
+            selected: string;
+            conditions: string;
+            operators: {
+                isEqual: string;
+                isNotEqual: string;
+                contains: string;
+                startsWith: string;
+                endsWith: string;
+                in: string;
+                isEmpty: string;
+                isNotEmpty: string;
+                greaterThan: string;
+                greaterThanOrEqual: string;
+                lessThan: string;
+                lessThanOrEqual: string;
+                after: string;
+                onOrAfter: string;
+                before: string;
+                onOrBefore: string;
+                isTrue: string;
+                isFalse: string;
+                custom: string;
+            };
+        };
+        splitter: {
+            handleLabel: string;
+        };
+        inputField: {
+            clearInput: string;
+        };
+        maskInput: {
+            roleDescription: string;
+            segmentRange: string;
+            optionSeparator: string;
+        };
+        drawer: {
+            close: string;
+        };
+        dialog: {
+            close: string;
+        };
+        chip: {
+            close: string;
+        };
+        breadcrumb: {
+            overflow: string;
+        };
+        toast: {
+            close: string;
+            region: string;
+        };
+        snackbar: {
+            close: string;
+            region: string;
+            severity: {
+                error: string;
+                warning: string;
+                success: string;
+                info: string;
+            };
+        };
+        upload: {
+            upload: string;
+            uploadNamed: string;
+            retryNamed: string;
+            cancelNamed: string;
+            removeNamed: string;
+            progressNamed: string;
+        };
+        select: {
+            filterOptions: string;
+        };
+        paginator: {
+            previousPage: string;
+            nextPage: string;
+        };
+        listBox: {
+            noItemsFound: string;
+        };
+        tree: {
+            noItemsFound: string;
+        };
+        table: {
+            selectAllRows: string;
+            selectRow: string;
+            sortedBy: string;
+            sortAscending: string;
+            sortDescending: string;
+            sortCleared: string;
+            selectedCount: string;
+            page: string;
+            resultCount: string;
+        };
+        state: {
+            loading: string;
+            success: string;
+            warning: string;
+            error: string;
+            cancelled: string;
+        };
+    }, "_">;
+    protected readonly theme: _ngneers_controls_api_ng.ControlTemplateInfo<_ngneers_controls_themes.ControlTemplate<"tree", ["root", "empty", "invalid", "item", "group", "default-item", "toggle", "toggle-placeholder", "toggle-icon", "toggle-arrow", "item-checkbox-placeholder", "item-selectable", "item-selected", "item-highlighted", "item-disabled", "item-expanded"], readonly [{
+        readonly class: "scroller";
+        readonly template: _ngneers_controls_themes.ControlTemplate<"scroller", ["root", "virtual", "item", "item-sticky"], readonly []>;
+    }, {
+        readonly class: "item-checkbox";
+        readonly template: _ngneers_controls_themes.ControlTemplate<"checkbox", ["root", "input", "box", "box-checked", "box-indeterminate", "box-icon", "box-icon-visible", "invalid"], readonly []>;
+    }]>>;
+    private readonly _scroller;
+    /** The tree items to render, as a nested list of {@link NgnTreeItem} objects. */
+    readonly items: _angular_core.InputSignal<Items>;
+    /**
+     * Whether nodes can be selected/checked.
+     * @default true
+     */
+    readonly selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the tree is focusable and participates in keyboard navigation.
+     * @default true
+     */
+    readonly focussable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the tree is virtualized. When enabled, provide {@link itemHeight}.
+     * @default false
+     */
+    readonly virtual: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * When {@link virtual} is enabled, this defines the height of each node in the list.
+     */
+    readonly itemHeight: _angular_core.InputSignal<number | undefined>;
+    /**
+     * Enable this to allow selecting multiple nodes. The value then becomes an array of node values.
+     * @default false
+     */
+    readonly multiple: _angular_core.InputSignal<Multiple | undefined>;
+    /**
+     * Whether to render checkboxes. Defaults to `multiple()`.
+     * @default multiple()
+     */
+    readonly checkbox: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * Boolean to enable filtering, or a `FilterConfig` to customize it.
+     * @default false
+     */
+    readonly filter: _angular_core.InputSignal<boolean | FilterConfig<Items[number]>>;
+    /** Manually set the filter text. */
+    readonly filterText: _angular_core.InputSignal<string | null>;
+    /** Values of expanded branch nodes (two-way). */
+    readonly expandedValues: _angular_core.ModelSignal<NgnTreeItemsValue<Items>[]>;
+    /**
+     * Persist expansion + selection state across reloads. Provide a key and,
+     * optionally, an `NgnStorageKind` (defaults to `'localstorage'`).
+     */
+    readonly storage: _angular_core.InputSignal<NgnTreeStorageConfig | null>;
+    private _storage?;
+    /**
+     * Loads the children of a `lazy` node the first time it is expanded.
+     * The returned items are cached internally and merged into the tree.
+     */
+    readonly loadChildren: _angular_core.InputSignal<((item: NgnTreeItem) => readonly NgnTreeItem[] | Promise<readonly NgnTreeItem[]>) | undefined>;
+    /** Emitted with the node's value whenever a node is clicked/selected. */
+    readonly itemClicked: _angular_core.OutputEmitterRef<NgnTreeItemsValue<Items>>;
+    /** Emitted when a branch is expanded (fires before any lazy load resolves). */
+    readonly nodeExpand: _angular_core.OutputEmitterRef<NgnTreeItem<any, any>>;
+    protected readonly maybeCallback: typeof maybeCallback;
+    /** Lazily-loaded children, keyed by node value. */
+    private readonly _loadedChildren;
+    /** Node values currently awaiting their lazy children. */
+    private readonly _loadingNodes;
+    protected readonly filteredItems: {
+        (): readonly NgnTreeItem<any, any>[];
+        isRunning: _angular_core.Signal<boolean>;
+        firstRunCompleted: _angular_core.Signal<boolean>;
+    };
+    private readonly _appliedFilterOptions;
+    protected readonly filterIsExecuting: _angular_core.Signal<boolean>;
+    /** While filtering, auto-expand every branch that survived the filter. */
+    private readonly _autoExpanded;
+    private readonly _expandedSet;
+    /** Filtered items with any lazily-loaded children merged in. */
+    private readonly _effectiveItems;
+    readonly flatNodes: _angular_core.Signal<FlatTreeNode<any, any>[]>;
+    protected readonly valueArray: _angular_core.Signal<NgnTreeItemsValue<Items>[]>;
+    private readonly _valueSet;
+    readonly currentHighlightedValue: _angular_core.WritableSignal<NgnTreeItemsValue<Items> | null>;
+    protected readonly showCheckboxes: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Create the store and restore persisted state before the first view check
+     * (so it also feeds the SSR render for the `cookie` kind without triggering
+     * ExpressionChangedAfterItHasBeenChecked).
+     *
+     * This is the common path: the `storage` config is normally bound before
+     * init, so the restore happens pre-render. When the config only becomes
+     * available after init (e.g. an async binding, or a dynamic host that applies
+     * inputs after creating the component), the constructor effect below picks it
+     * up instead — `_initStorage` is idempotent, so at most one of them runs.
+     */
+    ngOnInit(): void;
+    /** Create the store and restore persisted state. Runs at most once. */
+    private _initStorage;
+    /** Whether the given state should be persisted (all states when unset). */
+    private _persistsState;
+    /** Derived tri-state for a node's checkbox / aria-checked. */
+    protected nodeState(item: NgnTreeItem): 'checked' | 'unchecked' | 'indeterminate';
+    /** Whether a node can be selected/checked right now. */
+    protected isSelectable(node: FlatTreeNode): boolean;
+    /** Whether a lazy node is currently loading its children. */
+    protected isLoading(item: NgnTreeItem): boolean;
+    protected toggleExpand(item: NgnTreeItem): Promise<void>;
+    protected onRowClick(node: FlatTreeNode): void;
+    protected onSelect(item: NgnTreeItem): void;
+    scrollToIndex(index: number): void;
+    onKeyDown(event: KeyboardEvent): void;
+    private _currentNode;
+    private _moveHighlight;
+    private _expandOrEnter;
+    private _collapseOrLeave;
+    private _typeahead;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgnTree<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgnTree<any, any>, "ngn-tree", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "focussable": { "alias": "focussable"; "required": false; "isSignal": true; }; "virtual": { "alias": "virtual"; "required": false; "isSignal": true; }; "itemHeight": { "alias": "itemHeight"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "checkbox": { "alias": "checkbox"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "filterText": { "alias": "filterText"; "required": false; "isSignal": true; }; "expandedValues": { "alias": "expandedValues"; "required": false; "isSignal": true; }; "storage": { "alias": "storage"; "required": false; "isSignal": true; }; "loadChildren": { "alias": "loadChildren"; "required": false; "isSignal": true; }; }, { "expandedValues": "expandedValuesChange"; "itemClicked": "itemClicked"; "nodeExpand": "nodeExpand"; }, never, never, true, never>;
+}
+
+export { NgnTree, TreeTemplates, applyLoadedChildren, cascadeCheck, collectBranchValues, collectLeafValues, computeNodeState, flattenTree };
+export type { FlatTreeNode, NgnTreeStorageConfig, NgnTreeStorageState, ValueType };