@koobiq/components 20.4.1 → 21.0.0

package/types/koobiq-components-tree.d.ts

@@ -0,0 +1,1290 @@
+import { SelectionModel, DataSource, CollectionViewer, SelectionChange } from '@angular/cdk/collections';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, ViewContainerRef, OnDestroy, ElementRef, AfterContentChecked, AfterContentInit, OnInit, IterableDiffers, ChangeDetectorRef, TrackByFunction, Signal, IterableDiffer, DestroyRef, AfterViewInit, InjectionToken, QueryList, DoCheck, EventEmitter, Provider } from '@angular/core';
+import * as _koobiq_components_tree from '@koobiq/components/tree';
+import * as i1 from '@koobiq/components/core';
+import { IFocusableOption, KbqPseudoCheckboxState, KbqTitleTextRef, KbqPseudoCheckbox, KbqOptionActionComponent, FocusKeyManager, KbqMultipleInput, MultipleMode } from '@koobiq/components/core';
+import { FocusOrigin, FocusMonitor } from '@angular/cdk/a11y';
+import { KbqDropdownTrigger } from '@koobiq/components/dropdown';
+import { KbqTooltipTrigger } from '@koobiq/components/tooltip';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i2 from '@koobiq/components/icon';
+
+/**
+ * Tree control interface. User can implement TreeControl to expand/collapse dataNodes in the tree.
+ * The Tree will use this TreeControl to expand/collapse a node.
+ * User can also use it outside the `<kbq-tree>` to control the expansion status of the tree.
+ */
+interface TreeControl<T> {
+    /** The saved tree nodes data for `expandAll` action. */
+    dataNodes: T[];
+    /** The expansion model */
+    expansionModel: SelectionModel<T>;
+    filterModel: SelectionModel<T>;
+    filterValue: BehaviorSubject<T[] | string | null>;
+    /** Get depth of a given data node, return the level number. This is for flat tree node. */
+    getLevel(dataNode: T): number;
+    /**
+     * Whether the data node is expandable. Returns true if expandable.
+     * This is for flat tree node.
+     */
+    isExpandable(dataNode: T): boolean;
+    /** Gets a stream that emits whenever the given data node's children change. */
+    getChildren(dataNode: T): Observable<T[]>;
+    /** Whether the data node is expanded or collapsed. Return true if it's expanded. */
+    isExpanded(dataNode: T): boolean;
+    /** Get all descendants of a data node */
+    getDescendants(dataNode: T): any[];
+    /** Expand or collapse data node */
+    toggle(dataNode: T): void;
+    /** Expand one data node */
+    expand(dataNode: T): void;
+    /** Collapse one data node */
+    collapse(dataNode: T): void;
+    /** Expand all the dataNodes in the tree */
+    expandAll(): void;
+    /** Collapse all the dataNodes in the tree */
+    collapseAll(): void;
+    /** Toggle a data node by expand/collapse it and all its descendants */
+    toggleDescendants(dataNode: T): void;
+    /** Expand a data node and all its descendants */
+    expandDescendants(dataNode: T): void;
+    /** Collapse a data node and all its descendants */
+    collapseDescendants(dataNode: T): void;
+}
+
+/** Base tree control. It has basic toggle/expand/collapse operations on a single data node. */
+declare abstract class BaseTreeControl<T> implements TreeControl<T> {
+    dataNodes: T[];
+    /** A selection model with multi-selection to track expansion status. */
+    expansionModel: SelectionModel<T>;
+    filterModel: SelectionModel<T>;
+    filterValue: BehaviorSubject<string | T[] | null>;
+    /** Get depth of a given data node, return the level number. This is for flat tree node. */
+    getLevel: (dataNode: T) => number;
+    /**
+     * Whether the data node is expandable. Returns true if expandable.
+     * This is for flat tree node.
+     */
+    isExpandable: (dataNode: T) => boolean;
+    /** Gets a stream that emits whenever the given data node's children change. */
+    getChildren: (dataNode: T) => Observable<T[]>;
+    /** Gets a list of descendent data nodes of a subtree rooted at given data node recursively. */
+    abstract getDescendants(dataNode: T): T[];
+    /** Expands all data nodes in the tree. */
+    abstract expandAll(): void;
+    /** Toggles one single data node's expanded/collapsed state. */
+    toggle(dataNode: T): void;
+    /** Expands one single data node. */
+    expand(dataNode: T): void;
+    /** Collapses one single data node. */
+    collapse(dataNode: T): void;
+    /** Whether a given data node is expanded or not. Returns true if the data node is expanded. */
+    isExpanded(dataNode: T): boolean;
+    /** Toggles a subtree rooted at `node` recursively. */
+    toggleDescendants(dataNode: T): void;
+    /** Collapse all dataNodes in the tree. */
+    collapseAll(): void;
+    /** Expands a subtree rooted at given data node recursively. */
+    expandDescendants(dataNode: T): void;
+    /** Collapses a subtree rooted at given data node recursively. */
+    collapseDescendants(dataNode: T): void;
+}
+
+declare const kbqTreeSelectAllValue = "selectAll";
+interface FlatTreeControlFilter<T> {
+    result: T[];
+    handle(value: string | null, prevFilter?: FlatTreeControlFilter<T> | null): T[];
+}
+/**
+ * Default first stage of the filter pipeline: keeps the nodes whose view value matches the query.
+ *
+ * @docs-private
+ */
+declare class FilterByViewValue<T> implements FlatTreeControlFilter<T> {
+    private control;
+    result: T[];
+    constructor(control: FlatTreeControl<T>);
+    handle(value: string | null): T[];
+}
+/**
+ * Default last stage of the filter pipeline: re-adds the ancestors of every matched node so the
+ * matches stay reachable in the rendered hierarchy.
+ *
+ * @docs-private
+ */
+declare class FilterParentsForNodes<T> implements FlatTreeControlFilter<T> {
+    private control;
+    result: T[];
+    constructor(control: FlatTreeControl<T>);
+    handle(_: any, prevFilter: FlatTreeControlFilter<T>): T[];
+}
+declare class FilterByValues<T> implements FlatTreeControlFilter<T> {
+    private control;
+    result: T[];
+    private values;
+    constructor(control: FlatTreeControl<T>);
+    handle(_: any, prevFilter?: FlatTreeControlFilter<T>): T[];
+    setValues: (values: string[]) => void;
+    getValues(): string[];
+}
+
+declare function defaultCompareValues(firstValue: string, secondValue: string): boolean;
+declare function defaultCompareViewValues(firstViewValue: string, secondViewValue: string): boolean;
+/** Flat tree control. Able to expand/collapse a subtree recursively for flattened tree. */
+declare class FlatTreeControl<T> extends BaseTreeControl<T> {
+    getLevel: (dataNode: T) => number;
+    isExpandable: (dataNode: T) => boolean;
+    /** getValue will be used to determine if the tree contains value or not. Used in method hasValue */
+    getValue: (dataNode: T) => any;
+    /** getViewValue will be used for filter nodes. Returned value will be first argument in filterNodesFunction */
+    getViewValue: (dataNode: T) => string;
+    /** compareValues will be used to comparing values. */
+    compareValues: (firstValue: any, secondValue: any) => boolean;
+    /** compareValues will be used to comparing values. */
+    compareViewValues: (firstViewValue: any, secondViewValue: any) => boolean;
+    /** isDisabled will be used to determine if the node is disabled. */
+    isDisabled: (dataNode: T) => boolean;
+    expandedItemsBeforeFiltration: T[];
+    private filters;
+    /** Construct with flat tree data node functions getLevel, isExpandable, getValue and getViewValue. */
+    constructor(getLevel: (dataNode: T) => number, isExpandable: (dataNode: T) => boolean, 
+    /** getValue will be used to determine if the tree contains value or not. Used in method hasValue */
+    getValue: (dataNode: T) => any, 
+    /** getViewValue will be used for filter nodes. Returned value will be first argument in filterNodesFunction */
+    getViewValue: (dataNode: T) => string, 
+    /** compareValues will be used to comparing values. */
+    compareValues?: (firstValue: any, secondValue: any) => boolean, 
+    /** compareValues will be used to comparing values. */
+    compareViewValues?: (firstViewValue: any, secondViewValue: any) => boolean, 
+    /** isDisabled will be used to determine if the node is disabled. */
+    isDisabled?: (dataNode: T) => boolean);
+    getFilters(): FlatTreeControlFilter<T>[];
+    setFilters(...filters: FlatTreeControlFilter<T>[]): void;
+    /**
+     * Gets a list of the data node's subtree of descendent data nodes.
+     *
+     * To make this working, the `dataNodes` of the TreeControl must be flattened tree nodes
+     * with correct levels.
+     */
+    getDescendants(dataNode: T): T[];
+    /**
+     * Expands all data nodes in the tree.
+     *
+     * To make this working, the `dataNodes` variable of the TreeControl must be set to all flattened
+     * data nodes of the tree.
+     */
+    expandAll(): void;
+    /**
+     * Ancestors of a data node, outermost first.
+     *
+     * Derived from `dataNodes` rather than from a `parent` back-reference: the flattened nodes are in
+     * depth-first order, so scanning backwards from the node, the first node of a smaller level is its
+     * parent, and repeating with that level yields the whole chain. A data node whose shape carries no
+     * `parent` therefore resolves just as well as one that does.
+     *
+     * @param result Collector the ancestors are prepended to. Provided so callers can accumulate into
+     * an existing array; a fresh one is used when omitted.
+     */
+    getParents(node: T, result?: T[]): T[];
+    hasValue(value: string): T | undefined;
+    filterNodes(value?: string | null): void;
+    private updateFilterValue;
+    private saveExpansionState;
+    private restoreExpansionState;
+}
+
+/** Nested tree control. Able to expand/collapse a subtree recursively for NestedNode type. */
+declare class NestedTreeControl<T> extends BaseTreeControl<T> {
+    getChildren: (dataNode: T) => Observable<T[]>;
+    /**
+     * Construct with nested tree function getChildren.
+     *
+     * @param getChildren Must emit **synchronously** (e.g. `of(children)` or a `BehaviorSubject`).
+     * `getDescendants` walks the tree with `take(1)` and returns as soon as the recursion unwinds, so
+     * an asynchronous source yields an incomplete — usually empty — descendant list.
+     */
+    constructor(getChildren: (dataNode: T) => Observable<T[]>);
+    /**
+     * Expands all dataNodes in the tree.
+     *
+     * To make this working, the `dataNodes` variable of the TreeControl must be set to all root level
+     * data nodes of the tree.
+     */
+    expandAll(): void;
+    /** Gets a list of descendant dataNodes of a subtree rooted at given data node recursively. */
+    getDescendants(dataNode: T): T[];
+    /** A helper function to get descendants recursively. */
+    private _getDescendants;
+}
+
+/**
+ * Tree flattener to convert a normal type of node to node with children & level information.
+ * Transform nested nodes of type `T` to flattened nodes of type `F`.
+ *
+ * For example, the input data of type `T` is nested, and contains its children data:
+ *
+ * ```ts
+ * SomeNode: {
+ *     key: 'Fruits',
+ *     children: [
+ *         NodeOne: {
+ *             key: 'Apple'
+ *         },
+ *         NodeTwo: {
+ *             key: 'Pear'
+ *         }
+ *     ]
+ * }
+ * ```
+ *
+ * After flattener flatten the tree, the structure will become
+ *
+ * ```ts
+ * SomeNode: {
+ *     key: 'Fruits',
+ *     expandable: true,
+ *     level: 1
+ * },
+ * NodeOne: {
+ *     key: 'Apple',
+ *     expandable: false,
+ *     level: 2
+ * },
+ * NodeTwo: {
+ *     key: 'Pear',
+ *     expandable: false,
+ *     level: 2
+ * }
+ * ```
+ *
+ * and the output flattened type is `F` with additional information.
+ */
+declare class KbqTreeFlattener<T, F> {
+    transformFunction: (node: T, level: number, parent: F | null) => F;
+    getLevel: (node: F) => number;
+    isExpandable: (node: F) => boolean;
+    getChildren: (node: T) => Observable<T[]> | T[] | undefined | null;
+    constructor(transformFunction: (node: T, level: number, parent: F | null) => F, getLevel: (node: F) => number, isExpandable: (node: F) => boolean, getChildren: (node: T) => Observable<T[]> | T[] | undefined | null);
+    /** @docs-private */
+    flattenNode(node: T, level: number, resultNodes: F[], parent: F | null): F[];
+    /** @docs-private */
+    flattenChildren(children: T[], level: number, resultNodes: F[], parent: F | null): void;
+    /**
+     * Flatten a list of node type T to flattened version of node F.
+     * Please note that type T may be nested, and the length of `structuredData` may be different
+     * from that of returned list `F[]`.
+     */
+    flattenNodes(structuredData: T[]): F[];
+    /**
+     * Expand flattened node with current expansion status.
+     * The returned list may have different length.
+     */
+    expandFlattenedNodes(nodes: F[], treeControl: TreeControl<F>): F[];
+}
+/**
+ * Data source for flat tree.
+ * The data source need to handle expansion/collapsion of the tree node and change the data feed
+ * to `KbqTree`.
+ * The nested tree nodes of type `T` are flattened through `KbqTreeFlattener`, and converted
+ * to type `F` for `KbqTree` to consume.
+ */
+declare class KbqTreeFlatDataSource<T, F> extends DataSource<F> {
+    private treeControl;
+    private treeFlattener;
+    flattenedData: BehaviorSubject<F[]>;
+    expandedData: BehaviorSubject<F[]>;
+    filteredData: BehaviorSubject<F[]>;
+    get data(): T[];
+    set data(value: T[]);
+    private readonly _data;
+    constructor(treeControl: FlatTreeControl<F>, treeFlattener: KbqTreeFlattener<T, F>, initialData?: T[]);
+    connect(collectionViewer: CollectionViewer): Observable<F[]>;
+    filterHandler(): F[];
+    expansionHandler(_change: SelectionChange<F>): F[];
+    disconnect(): void;
+}
+
+/**
+ * Data source for nested tree.
+ *
+ * The data source for nested tree doesn't have to consider node flattener, or the way to expand
+ * or collapse. The expansion/collapsion will be handled by TreeControl and each non-leaf node.
+ */
+declare class KbqTreeNestedDataSource<T> extends DataSource<T> {
+    get data(): T[];
+    set data(value: T[]);
+    private _data;
+    connect(collectionViewer: CollectionViewer): Observable<T[]>;
+    disconnect(): void;
+}
+
+/** Context provided to the tree node component. */
+declare class KbqTreeNodeOutletContext<T> {
+    /** Data for the node. */
+    $implicit: T;
+    /** Depth of the node. */
+    level: number;
+    /** Index location of the node. */
+    index?: number;
+    /** Length of the number of total dataNodes. */
+    count?: number;
+    constructor(data: T);
+}
+/**
+ * Data node definition for the KbqTree.
+ * Captures the node's template and a when predicate that describes when this node should be used.
+ */
+declare class KbqTreeNodeDef<T> {
+    template: TemplateRef<any>;
+    readonly data: _angular_core.InputSignal<T>;
+    /**
+     * Function that should return true if this node template should be used for the provided node
+     * data and index. If left undefined, this node will be considered the default node template to
+     * use when no other when functions return true for the data.
+     * For every node, there must be at least one when function that passes or an undefined to
+     * default.
+     */
+    when: (index: number, nodeData: T) => boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTreeNodeDef<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTreeNodeDef<any>, "[kbqTreeNodeDef]", never, { "when": { "alias": "kbqTreeNodeDefWhen"; "required": false; }; "data": { "alias": "kbqTreeNode"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class KbqTreeNodeOutlet {
+    viewContainer: ViewContainerRef;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTreeNodeOutlet, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTreeNodeOutlet, "[kbqTreeNodeOutlet]", never, {}, {}, never, never, true, never>;
+}
+
+/** The persisted state of a tree — the values of the nodes that were expanded. */
+type KbqTreeState = string[];
+/**
+ * Rendering core of the tree.
+ *
+ * Originally forked from `@angular/cdk/tree` and maintained independently since: the node/outlet
+ * contract, the option-based selection model and the filtering pipeline have all diverged, so
+ * `@angular/cdk/tree` is deliberately not a dependency of this package and upstream fixes have to be
+ * ported by hand.
+ *
+ * `C` narrows the tree control a concrete tree accepts, and so the type its `treeControl` binding is checked against.
+ */
+declare class KbqTreeBase<T, C extends TreeControl<T> = TreeControl<T>> implements AfterContentChecked, AfterContentInit, CollectionViewer, OnDestroy, OnInit {
+    protected differs: IterableDiffers;
+    protected changeDetectorRef: ChangeDetectorRef;
+    /**
+     * Persistence of the expanded state, applied as a host directive by the concrete tree components.
+     * Optional because `KbqTreeBase` is exported: a tree without the directive persists nothing.
+     */
+    private readonly stateSaving;
+    /** @docs-private */
+    readonly treeControlInput: _angular_core.InputSignal<C>;
+    /** Controls the expanded state and holds the data nodes of the tree. */
+    get treeControl(): C;
+    /** {@link treeControl} as state saving reads it: by node value, which only a `FlatTreeControl` has. */
+    private get flatTreeControl();
+    /**
+     * Tracking function that will be used to check the differences in data changes. Used similarly
+     * to `ngFor` `trackBy` function. Optimize node operations by identifying a node based on its data
+     * relative to the function to know if a node should be added/removed/moved.
+     * Accepts a function that takes two parameters, `index` and `item`.
+     *
+     * Views are reused for nodes the function reports as unchanged, which a data source that rebuilds
+     * its node objects on every emission — a flattener among them — otherwise cannot get.
+     */
+    readonly trackBy: _angular_core.InputSignal<TrackByFunction<T>>;
+    private readonly nodeOutletQuery;
+    /** Outlet within the tree's template where the data nodes are inserted. */
+    get nodeOutlet(): KbqTreeNodeOutlet;
+    /** The tree node template for the tree */
+    readonly nodeDefs: Signal<readonly KbqTreeNodeDef<T>[]>;
+    /**
+     * Stream containing the latest information on what rows are being displayed on screen.
+     * Can be used by the data source to as a heuristic of what data should be provided.
+     *
+     * The tree renders every expanded node eagerly, so the window is the whole data set; a data source
+     * cannot use it to page or virtualize. Windowing would have to emit a real range from a scroll
+     * listener here first.
+     */
+    viewChange: BehaviorSubject<{
+        start: number;
+        end: number;
+    }>;
+    /** Differ used to find the changes in the data provided by the data source. */
+    protected dataDiffer: IterableDiffer<T>;
+    /** Stores the node definition that does not have a when predicate. */
+    private defaultNodeDef;
+    /** Data subscription */
+    private dataSubscription;
+    /** Level of nodes */
+    private levels;
+    /** Most recently constructed node of this tree, see `registerNode`. */
+    private recentNode;
+    /** Node rendered for a given outlet context, so a reused view can be handed its new data. */
+    private readonly nodesByContext;
+    /**
+     * Values from the persisted state whose node has not appeared in `treeControl.dataNodes` yet —
+     * applied as the nodes show up, and dropped the first time each node is seen.
+     */
+    private pendingValues;
+    /** The `dataNodes` the last restore ran against, so an unchanged list is not walked again. */
+    private lastRestoredDataNodes;
+    /**
+     * Whether the persisted state has been read. `KbqTreeSelect` calls `ngAfterContentInit()` by hand on
+     * the tree it projects into its panel, and a second read would resurrect values the user dismissed.
+     */
+    private hasRead;
+    /** Whether the dev-mode warnings below have already been logged, so each is logged once. */
+    private warnedAboutTreeControl;
+    private warnedAboutValues;
+    /** @docs-private */
+    readonly dataSourceInput: _angular_core.InputSignal<DataSource<T> | T[] | Observable<T[]> | null | undefined>;
+    /**
+     * Provides a stream containing the latest data array to render. Influenced by the tree's
+     * stream of view window (what dataNodes are currently on screen).
+     * Data source can be an observable of data array, or a data array to render.
+     */
+    get dataSource(): DataSource<T> | Observable<T[]> | T[] | null;
+    private _dataSource;
+    constructor();
+    protected readonly destroyRef: DestroyRef;
+    /** Whether `ngAfterContentChecked` has run, i.e. the node definitions the first render needs are resolved. */
+    private contentChecked;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    /** Reads the persisted expansion and applies it. Runs while initializing, and again on a key change. */
+    private restoreState;
+    ngOnDestroy(): void;
+    ngAfterContentChecked(): void;
+    /**
+     * Persists the values of the currently expanded nodes.
+     *
+     * Called for every expansion and collapse a user performs. Expansion driven by the application —
+     * `treeControl.expandAll()`, or writing to `expansionModel` — is not persisted; call this to record it.
+     *
+     * A no-op while a filter is active: what is expanded then is the result set, not a chosen state.
+     */
+    saveState(): void;
+    /**
+     * Removes the state persisted for this tree.
+     *
+     * Persistence itself stays on — the next expansion is written again.
+     */
+    clearSavedState(): void;
+    /**
+     * Whether state is currently persisted for this tree — restored on init, or written since.
+     * Always `false` while `useStateSaving` is unset, and `false` again after `clearSavedState()`.
+     */
+    get hasSavedState(): boolean;
+    /** Check for changes made in the data and render each change (node added/removed/moved). */
+    renderNodeChanges(data: T[] | ReadonlyArray<T>, dataDiffer?: IterableDiffer<T>, viewContainer?: ViewContainerRef, parentData?: T): void;
+    /**
+     * Applies the data changes to the view container without running change detection, and reports
+     * whether anything moved. Split out of `renderNodeChanges` so a subclass can update the state its
+     * own template reads before the single change-detection pass, instead of running a second one.
+     *
+     * @docs-private
+     */
+    protected applyNodeChanges(data: T[] | ReadonlyArray<T>, dataDiffer: IterableDiffer<T>, viewContainer: ViewContainerRef, parentData?: T): boolean;
+    private refreshNodeData;
+    /**
+     * Finds the matching node definition that should be used for this node data. If there is only
+     * one node definition, it is returned. Otherwise, find the node definition that has a when
+     * predicate that returns true with the data. If none return true, return the default node
+     * definition.
+     */
+    getNodeDef(data: T, i: number): KbqTreeNodeDef<T>;
+    /**
+     * Create the embedded view for the data node template and place it in the correct index location
+     * within the data node view container.
+     */
+    insertNode(nodeData: T, index: number, viewContainer?: ViewContainerRef, parentData?: T): void;
+    /**
+     * Called by a `KbqTreeNode` while it is being constructed, so `insertNode` can hand it its data.
+     *
+     * @docs-private
+     */
+    registerNode(node: KbqTreeNode<T>): void;
+    /** Whether this tree reads and writes its expanded state at all. */
+    private get persists();
+    /**
+     * Expands every pending value whose node is present, and stops tracking it.
+     *
+     * Idempotent, and safe to call on every render: the pending set only shrinks, so a tree that has
+     * restored everything does no work at all.
+     */
+    private restorePending;
+    /** The values of the nodes that are currently expanded, plus the ones still waiting to appear. */
+    private expandedValues;
+    /** Set up a subscription for the data provided by the data source. */
+    private observeRenderChanges;
+    /**
+     * Switch to the provided data source by resetting the data and unsubscribing from the current
+     * render change subscription if one exists. If the data source is null, interpret this by
+     * clearing the node outlet. Otherwise start listening for new data.
+     */
+    private switchDataSource;
+    private createDataDiffer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTreeBase<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTreeBase<any, any>, never, never, { "treeControlInput": { "alias": "treeControl"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "dataSourceInput": { "alias": "dataSource"; "required": false; "isSignal": true; }; }, {}, ["nodeDefs"], never, true, never>;
+}
+declare class KbqTreeNode<T> implements IFocusableOption, OnDestroy {
+    protected elementRef: ElementRef<HTMLElement>;
+    tree: KbqTreeBase<T, TreeControl<T>>;
+    /**
+     * The most recently created `KbqTreeNode`, across every tree on the page.
+     *
+     * @deprecated Kept for backwards compatibility only — the tree hands a node its data through
+     * `KbqTreeBase.registerNode`, which is scoped to the tree that owns the node. Will be removed in 22.0.0.
+     */
+    static mostRecentTreeNode: KbqTreeNode<any> | null;
+    protected destroyed: Subject<void>;
+    /**
+     * Emits after the tree reused this node's view for a different data object, so a directive on the
+     * same element can re-derive what it computed from the previous one.
+     *
+     * @docs-private
+     */
+    readonly refreshed: Subject<void>;
+    get data(): T;
+    set data(value: T);
+    private _data;
+    get isExpanded(): boolean;
+    get level(): number;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * Called by the tree once `data` has been replaced on a reused view. State a subclass derived from
+     * the previous node — its value, its level — is stale at this point and has to be recomputed.
+     *
+     * @docs-private
+     */
+    refresh(): void;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTreeNode<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTreeNode<any>, "kbq-tree-node", ["kbqTreeNode"], {}, {}, never, never, true, never>;
+}
+
+declare class KbqTreeNodePadding<T> implements AfterViewInit {
+    protected treeNode: KbqTreeNode<T>;
+    protected tree: KbqTreeBase<T, _koobiq_components_tree.TreeControl<T>>;
+    private renderer;
+    private element;
+    private option;
+    private dir;
+    get level(): number;
+    set level(value: number);
+    private _level;
+    /** Indentation added per nesting level. Accepts a bare number (px) or a value with CSS units. */
+    readonly indent: _angular_core.InputSignal<string | number>;
+    private readonly parsedIndent;
+    get leftPadding(): number;
+    get leftPaddingForFirstLevel(): number;
+    /** CSS units used for the indentation value. */
+    get indentUnits(): string;
+    withIcon: boolean;
+    /**
+     * Horizontal room a toggle takes up in a row: its own 16px box plus the option's 8px `gap`. A node
+     * without a toggle reserves the same amount so its content lines up with a sibling that has one —
+     * which is why widening the toggle itself pushes every branch row out of line.
+     */
+    iconWidth: number;
+    constructor();
+    ngAfterViewInit(): void;
+    paddingIndent(): string | null;
+    /**
+     * This has been extracted to a util because of TS 4 and VE.
+     * View Engine doesn't support property rename inheritance.
+     * TS 4.0 doesn't allow properties to override accessors or vice-versa.
+     */
+    private setLevelInput;
+    private setPadding;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTreeNodePadding<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTreeNodePadding<any>, "[kbqTreeNodePadding]", ["kbqTreeNodePadding"], { "indent": { "alias": "kbqTreeNodePaddingIndent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** @docs-private */
+declare class KbqTreeNodeToggleBaseDirective<T> {
+    private tree;
+    private treeNode;
+    readonly node: _angular_core.InputSignal<T>;
+    /** Whether toggling expands or collapses the whole subtree instead of the node alone. */
+    readonly recursive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Backing input of `disabled`. Bind through the `disabled` attribute; read the `disabled` getter,
+     * which also reports the toggle disabled while a filter is active.
+     *
+     * @docs-private
+     */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Set while a filter is active: filtering already decides what is expanded. */
+    private readonly filterDisabled;
+    private readonly disabledState;
+    get disabled(): boolean;
+    get iconState(): boolean;
+    toggle(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTreeNodeToggleBaseDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTreeNodeToggleBaseDirective<any>, never, never, { "node": { "alias": "node"; "required": false; "isSignal": true; }; "recursive": { "alias": "kbqTreeNodeToggleRecursive"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class KbqTreeNodeToggleComponent<T> extends KbqTreeNodeToggleBaseDirective<T> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTreeNodeToggleComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqTreeNodeToggleComponent<any>, "kbq-tree-node-toggle", ["kbqTreeNodeToggle"], {}, {}, never, ["*"], true, never>;
+}
+declare class KbqTreeNodeToggleDirective<T> extends KbqTreeNodeToggleBaseDirective<T> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTreeNodeToggleDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTreeNodeToggleDirective<any>, "[kbq-tree-node-toggle], [kbqTreeNodeToggle]", ["kbqTreeNodeToggle"], {}, {}, never, never, true, never>;
+}
+
+declare class KbqTree extends KbqTreeBase<any> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTree, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqTree, "kbq-tree", ["kbqTree"], {}, {}, never, never, true, [{ directive: typeof i1.KbqStateSaving; inputs: { "useStateSaving": "useStateSaving"; "stateSavingKey": "stateSavingKey"; }; outputs: {}; }]>;
+}
+
+interface KbqTreeOptionEvent {
+    option: KbqTreeOption;
+}
+/**
+ * The part of the tree an option talks to.
+ *
+ * Declared as an interface rather than as `KbqTreeSelection` so the token stays free of a circular
+ * import, and so anything embedding options only has to provide these members.
+ */
+interface KbqTreeOptionParent<T = any> {
+    /** Whether the whole tree is disabled. */
+    disabled: boolean;
+    /** Whether more than one option can be selected at a time. */
+    multiple: boolean;
+    /** Whether the options render a checkbox. */
+    showCheckbox: boolean;
+    /** Whether the tree is rendered inside a select panel, which makes hovering an option focus it. */
+    inSelect: boolean;
+    /** Whether an option keeps focus while the tree loses it, as a select with a search field needs. */
+    optionShouldHoldFocusOnBlur: boolean;
+    /** State of the tree-level "select all" checkbox. */
+    selectAllState: KbqPseudoCheckboxState;
+    treeControl: FlatTreeControl<T>;
+    selectionModel: SelectionModel<T>;
+    unorderedOptions: QueryList<KbqTreeOption<T>>;
+    setSelectedOptionsByClick(option: KbqTreeOption<T>, shiftKey: boolean, ctrlKey: boolean): void;
+}
+/** Injection token used to provide the parent component to options. */
+declare const KBQ_TREE_OPTION_PARENT_COMPONENT: InjectionToken<KbqTreeOptionParent>;
+/** Represents a change event for a tree option. */
+declare class KbqTreeOptionChange {
+    /** The tree option that has been modified or selected. */
+    source: KbqTreeOption;
+    constructor(
+    /** The tree option that has been modified or selected. */
+    source: KbqTreeOption);
+}
+declare class KbqTreeOption<T = any> extends KbqTreeNode<T> implements AfterContentInit, DoCheck, KbqTitleTextRef {
+    private changeDetectorRef;
+    private readonly environmentInjector;
+    private readonly destroyRef;
+    tree: KbqTreeOptionParent<T> & KbqTreeBase<T>;
+    private readonly focusEvents;
+    private readonly blurEvents;
+    /** Emits when the option takes focus. */
+    readonly onFocus: Observable<KbqTreeOptionEvent>;
+    /** Emits when the option loses focus. */
+    readonly onBlur: Observable<KbqTreeOptionEvent>;
+    preventBlur: boolean;
+    private readonly titleContainer;
+    /** Container of the option text, measured by `kbq-title`. */
+    get parentTextElement(): ElementRef<HTMLElement> | undefined;
+    get textElement(): ElementRef<HTMLElement> | undefined;
+    readonly toggleElementDirective: _angular_core.Signal<KbqTreeNodeToggleDirective<any> | undefined>;
+    readonly toggleElementComponent: _angular_core.Signal<KbqTreeNodeToggleComponent<any> | undefined>;
+    readonly pseudoCheckbox: _angular_core.Signal<KbqPseudoCheckbox | undefined>;
+    readonly actionButton: _angular_core.Signal<KbqOptionActionComponent | undefined>;
+    private readonly tooltipTriggerQuery;
+    private readonly dropdownTriggerQuery;
+    /** Tooltip trigger projected into the option. */
+    get tooltipTrigger(): KbqTooltipTrigger | undefined;
+    /** Dropdown trigger projected into the option. */
+    get dropdownTrigger(): KbqDropdownTrigger | undefined;
+    readonly checkboxThirdState: _angular_core.InputSignal<boolean>;
+    get externalPseudoCheckbox(): boolean;
+    get value(): any;
+    set value(value: any);
+    private _value;
+    /** @docs-private */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, string | boolean | null | undefined>;
+    /** Whether the option is disabled: through its own input, the tree, or the tree control's `isDisabled`. */
+    get disabled(): boolean;
+    /**
+     * `disabled` as of the last check, which the host bindings read: the tree control's `isDisabled` predicate gives
+     * no notice of a change and may be costly, so a check asks it once.
+     */
+    protected checkedDisabled: boolean;
+    /**
+     * What the tree control's `isDisabled` and `isExpandable` say about the row. Derived, so a predicate reading a
+     * signal brings the row back once that signal changes; `ngDoCheck` sets it on every check for one reading plain
+     * state. Read by a single host binding, see `ariaExpanded`.
+     */
+    private readonly predicates;
+    private checkedAriaSelected;
+    private checkedSelectAllState;
+    private checkedCheckboxRow;
+    /**
+     * Whether the option can be selected by user interaction (click, keyboard, select all).
+     * A non-selectable option remains focusable, navigable and expandable.
+     * Programmatic selection (`setSelected`, `select`, value accessor) is not affected.
+     * Options that are not rendered (e.g. collapsed) are not checked by "select all".
+     */
+    readonly selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether this option is the tree's "select all" row rather than a rendered data node.
+     *
+     * Such a row has no `data`, so everything that would resolve the option against the tree control
+     * (`getValue`, `isDisabled`, `isExpandable`, descendants) is skipped — those accessors belong to the
+     * consumer and must never be handed a node their data source has never seen. Its checkbox state and
+     * selection are driven from the outside instead.
+     *
+     * @docs-private
+     */
+    readonly selectAllRow: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** @docs-private */
+    readonly showCheckboxInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** Whether the option renders a pseudo-checkbox. Falls back to the tree's own mode until bound. */
+    get showCheckbox(): boolean;
+    /** Emits whenever the selected state of the option changes. */
+    readonly selectionChange: _angular_core.OutputEmitterRef<KbqTreeOptionChange>;
+    /** @deprecated Use `selectionChange` instead. Will be removed in 22.0.0. */
+    readonly onSelectionChange: _angular_core.OutputEmitterRef<KbqTreeOptionChange>;
+    readonly userInteraction: EventEmitter<void>;
+    get selected(): boolean;
+    set selected(value: boolean);
+    private readonly selectedState;
+    get id(): string;
+    private _id;
+    get viewValue(): string;
+    get hasFocus(): boolean;
+    set hasFocus(value: boolean);
+    private readonly focused;
+    get isExpandable(): boolean;
+    /** The "select all" row sits above the tree at root depth; `getLevel` has no node to resolve for it. */
+    get level(): number;
+    get toggleElement(): KbqTreeNodeToggleBaseDirective<T> | undefined;
+    get isToggleInDefaultPlace(): boolean;
+    get checkboxState(): KbqPseudoCheckboxState;
+    set checkboxState(value: KbqPseudoCheckboxState);
+    private readonly checkbox;
+    /**
+     * `aria-expanded` of the row as of the last check, reported for every branch and omitted on a leaf.
+     *
+     * Deliberately not `isExpandable`, which also asks whether the toggle is operable: filtering
+     * disables every toggle while leaving the matched branches expanded, and a branch that stops
+     * reporting `aria-expanded` is announced as a leaf while its children are on screen.
+     */
+    protected get ariaExpanded(): boolean | null;
+    /**
+     * `aria-checked` of the row: tri-state for a checkbox option, and the "select all" state for the
+     * row that drives it. `null` for a plain option, which reports `aria-selected` instead.
+     */
+    protected get ariaChecked(): string | null;
+    /** `aria-selected` of the row as of the last check. Options with a checkbox report `aria-checked` instead. */
+    protected get ariaSelected(): boolean | null;
+    constructor();
+    ngDoCheck(): void;
+    ngAfterContentInit(): void;
+    /**
+     * The value and the checkbox state were derived from the node this view held before it was reused,
+     * and `ngAfterContentInit` does not run again. A stale `value` drops the row out of the tree's
+     * `renderedOptions`, so it renders but can no longer be focused, selected or copied.
+     *
+     * @docs-private
+     */
+    refresh(): void;
+    descendantsAllSelected(): boolean;
+    descendantsPartiallySelected(): boolean;
+    updateParentsCheckboxState(node: T): void;
+    updateCheckboxState: () => void;
+    toggle(): void;
+    setSelected(selected: boolean): void;
+    focus(focusOrigin?: FocusOrigin): void;
+    blur(): void;
+    /** @docs-private */
+    getHeight(): number;
+    /**
+     * Label the key manager's type-ahead matches against.
+     *
+     * The "select all" row is navigable but is not a data node, and its label is a localized phrase —
+     * answering type-ahead with it would hijack every query starting with that letter.
+     *
+     * @docs-private
+     */
+    getLabel(): string;
+    select(setFocus?: boolean): void;
+    deselect(): void;
+    onKeydown($event: any): void;
+    selectViaInteraction($event?: KeyboardEvent | MouseEvent): void;
+    emitSelectionChangeEvent(): void;
+    getHostElement(): HTMLElement;
+    markForCheck(): void;
+    /** @docs-private */
+    protected onMouseenter(): void;
+    /** Recomputes the option's own checkbox state, leaving its ancestors as they are. */
+    private syncCheckboxState;
+    private toAriaChecked;
+    private resolvePredicates;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTreeOption<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqTreeOption<any>, "kbq-tree-option", ["kbqTreeOption"], { "checkboxThirdState": { "alias": "checkboxThirdState"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selectAllRow": { "alias": "selectAllRow"; "required": false; "isSignal": true; }; "showCheckboxInput": { "alias": "showCheckbox"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "onSelectionChange": "onSelectionChange"; }, ["toggleElementDirective", "toggleElementComponent", "pseudoCheckbox", "actionButton", "tooltipTriggerQuery", "dropdownTriggerQuery"], ["kbq-tree-node-toggle, [kbq-tree-node-toggle], [kbqTreeNodeToggle]", "kbq-pseudo-checkbox", "kbq-checkbox", "[kbq-icon]", "kbq-progress-spinner", "*", "kbq-option-action"], true, never>;
+}
+
+declare const KBQ_SELECTION_TREE_VALUE_ACCESSOR: Provider;
+declare class KbqTreeSelectAllEvent<T, N = any> {
+    source: KbqTreeSelection<N>;
+    options: T[];
+    constructor(source: KbqTreeSelection<N>, options: T[]);
+}
+/**
+ * Event class that occurs when copying an item from the KbqTreeSelection.
+ * Used to pass data about the copied item and copy context.
+ *
+ * @param source - instance of KbqTreeSelection
+ * @param option - instance of KbqTreeOption
+ * @param event - original keyboard event (optional) that triggered the copy
+ */
+declare class KbqTreeCopyEvent<T, N = any> {
+    source: KbqTreeSelection<N>;
+    option: T;
+    event?: KeyboardEvent | undefined;
+    constructor(source: KbqTreeSelection<N>, option: T, event?: KeyboardEvent | undefined);
+}
+declare class KbqTreeNavigationChange<T, N = any> {
+    source: KbqTreeSelection<N>;
+    option: T;
+    constructor(source: KbqTreeSelection<N>, option: T);
+}
+declare class KbqTreeSelectionChange<T, N = any> {
+    source: KbqTreeSelection<N>;
+    option: T;
+    options?: T[] | undefined;
+    constructor(source: KbqTreeSelection<N>, option: T, options?: T[] | undefined);
+}
+declare class KbqTreeSelection<T = any> extends KbqTreeBase<T, FlatTreeControl<T>> implements ControlValueAccessor, AfterContentInit, AfterViewInit, OnDestroy {
+    private elementRef;
+    private scheduler;
+    private clipboard;
+    private readonly platform;
+    private readonly injector;
+    protected readonly focusMonitor: FocusMonitor;
+    /**
+     * Whether this tree-selection is rendered inside a select panel (enables option
+     * hover-to-focus). Defaults to detecting a wrapping `KbqFormField`, and is forced to `true`
+     * by the host `KbqTreeSelect` so hover works even when the tree-select has no form-field
+     * wrapper (e.g. the filter-bar pipes render the tree-select bare).
+     */
+    inSelect: boolean;
+    renderedOptions: QueryList<KbqTreeOption<T>>;
+    keyManager: FocusKeyManager<KbqTreeOption<T>>;
+    /**
+     * Accessible name of the tree. Set it whenever the tree has no visible label of its own; a tree
+     * embedded in a `kbq-tree-select` is labelled by the select instead.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Id of the element that labels the tree, for when the label is rendered next to it. */
+    readonly ariaLabelledby: _angular_core.InputSignal<string>;
+    /**
+     * Accessible name written to the host.
+     *
+     * The host is the very element the consumer writes, and a host binding runs after their own
+     * `[attr.aria-label]` binding on that element — an unset input reporting `null` would erase the name
+     * they just set, because `[attr.]` never reaches the aliased input. Whatever is already on the
+     * element therefore stands in for an unset input.
+     */
+    protected get resolvedAriaLabel(): string | null;
+    /** Labelling element of the host. Falls back to the element's own attribute, see `resolvedAriaLabel`. */
+    protected get resolvedAriaLabelledby(): string | null;
+    /**
+     * Model backing the selection.
+     *
+     * The instance is replaced whenever {@link multiple} changes the multiplicity, because CDK freezes that
+     * flag at construction. Subscribe to {@link selectionChange} rather than to `selectionModel.changed`:
+     * a subscription taken on the model directly is left behind on the discarded instance.
+     *
+     * `T` is the type of the data nodes, inferred from `[treeControl]` in a template. A query names it:
+     * `viewChild.required<KbqTreeSelection<Node>>(KbqTreeSelection)`.
+     */
+    selectionModel: SelectionModel<T>;
+    resetFocusedItemOnBlur: boolean;
+    userTabIndex: number | null;
+    optionShouldHoldFocusOnBlur: boolean;
+    /**
+     * Whether the tree acts on keyboard input itself. Turned off by an embedding host that owns the
+     * keyboard, such as `KbqTreeSelect`.
+     */
+    ownsKeyboard: boolean;
+    /** Reference to the built-in "select all" row, rendered only while `selectAll` is on. */
+    readonly selectAllOption: _angular_core.Signal<KbqTreeOption<T> | undefined>;
+    private readonly unorderedOptionsQuery;
+    private readonly unorderedOptionsList;
+    get unorderedOptions(): QueryList<KbqTreeOption<T>>;
+    readonly navigationChange: _angular_core.OutputEmitterRef<KbqTreeNavigationChange<KbqTreeOption<T>, T>>;
+    /**
+     * Emits when the selection changes. A stream rather than an `output()`: `KbqTreeSelect` pipes it with rxjs.
+     */
+    readonly selectionChange: EventEmitter<KbqTreeSelectionChange<KbqTreeOption<T>, T>>;
+    /** @docs-private */
+    readonly selectionChangeOutput: _angular_core.OutputRef<KbqTreeSelectionChange<KbqTreeOption<T>, T>>;
+    /** Emits after "select all" ran, with the options it could act on. */
+    readonly selectAllChange: _angular_core.OutputEmitterRef<KbqTreeSelectAllEvent<KbqTreeOption<T>, T>>;
+    /** @deprecated Use `selectAllChange` instead. Will be removed in 22.0.0. */
+    readonly onSelectAll: _angular_core.OutputEmitterRef<KbqTreeSelectAllEvent<KbqTreeOption<T>, T>>;
+    /**
+     * Emits when the active option is copied with Ctrl/Cmd + C. Subscribing replaces the built-in
+     * clipboard handler, so the event has to stay an `EventEmitter`: the decision is made by reading
+     * `observed`, which `OutputEmitterRef` does not have. A template listener subscribes to it through
+     * the output below.
+     */
+    readonly copyChange: EventEmitter<KbqTreeCopyEvent<KbqTreeOption<T>, T>>;
+    /** @docs-private */
+    readonly copyChangeOutput: _angular_core.OutputRef<KbqTreeCopyEvent<KbqTreeOption<T>, T>>;
+    /** @deprecated Use `copyChange` instead. Will be removed in 22.0.0. */
+    readonly onCopy: EventEmitter<KbqTreeCopyEvent<KbqTreeOption<T>, T>>;
+    /** @docs-private */
+    readonly onCopyOutput: _angular_core.OutputRef<KbqTreeCopyEvent<KbqTreeOption<T>, T>>;
+    private sortedNodes;
+    private lastSyncedDataNodes;
+    /** @docs-private */
+    readonly autoSelectInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** `undefined` while the value is derived from the mode. Written by `KbqTreeSelect` as well. */
+    private readonly autoSelectState;
+    /**
+     * Whether clicking a node clears the rest of the selection. Defaults to `true`, and to `false` for
+     * `multiple="checkbox"`.
+     *
+     * Assigning it — from a template binding or imperatively, as `KbqTreeSelect` does — replaces the
+     * derived default, so a later {@link multiple} change leaves the value alone.
+     */
+    get autoSelect(): boolean;
+    set autoSelect(value: boolean);
+    get optionFocusChanges(): Observable<KbqTreeOptionEvent>;
+    get optionBlurChanges(): Observable<KbqTreeOptionEvent>;
+    /**
+     * Selection mode of the tree.
+     *
+     * `checkbox` renders a checkbox in every node, `keyboard` selects without one. A bare `multiple` and
+     * `true` both mean `checkbox`; `single`, `false` and an absent attribute mean single selection. The mode
+     * can be changed at any time — narrowing it to single selection keeps the first selected node and
+     * reports the shortened value through the `ControlValueAccessor`.
+     *
+     * A tree rendered inside a `kbq-tree-select` shares its `SelectionModel` with the select, so the
+     * select decides how many nodes may be selected: switching this input between single and multiple
+     * selection there throws. Switching between `checkbox` and `keyboard` only changes the presentation
+     * and is allowed.
+     *
+     * The getter reports whether more than one node can be selected; read {@link multipleMode} for the mode
+     * itself.
+     */
+    get multiple(): boolean;
+    /** @docs-private */
+    readonly multipleInput: _angular_core.InputSignal<KbqMultipleInput>;
+    /** Resolved selection mode, or `null` when only one node can be selected. */
+    get multipleMode(): MultipleMode | null;
+    set multipleMode(value: MultipleMode | null);
+    /**
+     * Backing signal of {@link multipleMode}. A signal rather than a field because the mode is also written
+     * from inside the component and by `KbqTreeSelect`: options read it through `multiple` and
+     * `showCheckbox`, and only a signal read re-runs their `OnPush` views and host bindings.
+     */
+    private readonly mode;
+    /** @docs-private */
+    readonly noUnselectLastInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** `undefined` while the value is derived from the mode. Written by `KbqTreeSelect` as well. */
+    private readonly noUnselectLastState;
+    /**
+     * Whether the last selected node can be deselected.
+     * Derived from the mode until assigned, like {@link autoSelect}.
+     */
+    get noUnselectLast(): boolean;
+    set noUnselectLast(value: boolean);
+    /**
+     * Whether typing printable characters moves the focus to the next option whose label starts with
+     * them. On by default.
+     *
+     * Turn it off wherever the tree shares its keystrokes with a text field: an embedder such as
+     * `KbqTreeSelect` routes everything the user types — the search query included — into this key
+     * manager, and type-ahead would move the active option out from under the query.
+     */
+    get typeAhead(): boolean;
+    set typeAhead(value: boolean);
+    /** @docs-private */
+    readonly typeAheadInput: _angular_core.InputSignalWithTransform<boolean, string | boolean | null | undefined>;
+    private readonly typeAheadState;
+    /** When `true`, a repeated Ctrl/Cmd+A deselects all options. Off by default (Ctrl+A only selects). */
+    readonly selectAllToggle: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether to render the "select all" master checkbox above the nodes. Multiple selection only.
+     *
+     * Enabling it also makes Ctrl/Cmd + A a two-way toggle, so the shortcut and the checkbox never
+     * disagree (`selectAllToggle` is implied).
+     */
+    get selectAll(): boolean;
+    set selectAll(value: boolean);
+    /** @docs-private */
+    readonly selectAllInput: _angular_core.InputSignalWithTransform<boolean, string | boolean | null | undefined>;
+    private readonly selectAllEnabled;
+    /** Whether the "select all" row is currently rendered. */
+    protected get showSelectAll(): boolean;
+    /** Whether every node "select all" can act on is selected. */
+    get allOptionsSelected(): boolean;
+    /** State of the "select all" master checkbox. */
+    get selectAllState(): KbqPseudoCheckboxState;
+    /** Label of the "select all" row. Follows the active locale. */
+    protected get selectAllText(): string;
+    private readonly localeConfiguration;
+    /**
+     * Data nodes "select all" acts on, and the ones its checkbox state is derived from.
+     *
+     * While a filter is active only the rendered nodes qualify — the hidden ones are not what the user
+     * is looking at, and selecting them would contradict a master checkbox that can only report on what
+     * is on screen. Without a filter the whole data set qualifies, collapsed branches included.
+     */
+    private get selectAllTargets();
+    /** Adapter shared by the master checkbox and the Ctrl/Cmd + A handler, so the two cannot drift apart. */
+    private get selectAllAdapter();
+    /** @docs-private */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** Whether the tree is disabled, bound with `[disabled]` or set by a form control. */
+    get disabled(): boolean;
+    private readonly disabledState;
+    /** @docs-private */
+    readonly tabIndexInput: _angular_core.InputSignalWithTransform<number | undefined, string | number | null | undefined>;
+    /** Tab index of the tree, `-1` while it is disabled. */
+    get tabIndex(): number;
+    private readonly tabIndexState;
+    get showCheckbox(): boolean;
+    get isEmpty(): boolean;
+    /**
+     * Number of real, data-backed nodes currently rendered — unlike `renderedOptions.length`, never
+     * includes the "select all" row, which is appended to `renderedOptions` on its own, later-processed
+     * reactive pass and would otherwise make a consumer's own node count race against that pass.
+     */
+    get nodesCount(): number;
+    private optionFocusSubscription;
+    private optionBlurSubscription;
+    private selectionModelSubscription;
+    /** Whether a value report is queued for the end of the current tick. Cleared by `writeValue` to cancel it. */
+    private pendingValueReport;
+    /** The `multiple` binding the mode was last set from, see `applyMultipleInput`. */
+    private appliedMultipleInput;
+    /** The `disabled` binding the state was last set from, see `applyDisabledInput`. */
+    private appliedDisabledInput;
+    /** Backs {@link syncingSelection}: a change of the selection made by code is no change to report back. */
+    private writingValue;
+    /**
+     * Whether the tree is changing the selection model itself — to a value the form wrote, or onto the nodes of
+     * reloaded data — rather than acting on the user. A host sharing the model, such as `KbqTreeSelect`, reports
+     * no such change.
+     *
+     * @docs-private
+     */
+    get syncingSelection(): boolean;
+    /**
+     * The last value the form wrote while some of the nodes it names were not in the data yet. Applied again as the
+     * data changes, until every node is found or the selection is reported to the form.
+     */
+    private unresolvedValue;
+    private destroyed;
+    /** `treeControl.dataNodes` the options' checkbox states were last recomputed against. */
+    private checkboxSyncedDataNodes;
+    /**
+     * The model this tree built for itself. `KbqTreeSelect` overwrites {@link selectionModel} with one it
+     * shares with the tree, and the two diverging is how a mode change knows the model is not ours to swap.
+     */
+    private ownSelectionModel;
+    constructor();
+    /** Selects every node "select all" can act on, or deselects them all when they are already selected. */
+    protected toggleSelectAll(): void;
+    /**
+     * Sets the mode from the `multiple` binding, once per bound value: an unbound input leaves what
+     * `KbqTreeSelect` or the {@link multipleMode} setter wrote, and a value bound back to `undefined` means
+     * single selection.
+     *
+     * Called by an effect, and by `writeValue` ahead of it: a forms directive on this element writes the
+     * value from its own `ngOnChanges`, which runs before any effect of the view.
+     */
+    private applyMultipleInput;
+    /**
+     * Sets the disabled state from the `disabled` binding, once per bound value, so that whichever of the binding
+     * and the form control changed last wins. An unbound input leaves what the form control wrote.
+     *
+     * Called by an effect, and by `setDisabledState` ahead of it: a forms directive on this element calls that
+     * from its own `ngOnChanges`, after the binding is set but before any effect of the view runs.
+     */
+    private applyDisabledInput;
+    /**
+     * Applies a new selection mode, rebuilding the `SelectionModel` when the multiplicity itself changes —
+     * CDK freezes that flag at construction, so the model has to be replaced rather than reconfigured.
+     */
+    private setMultipleMode;
+    /** Replaces the `SelectionModel` with one of the given multiplicity, keeping what the new one can hold. */
+    private rebuildSelectionModel;
+    /**
+     * Reports the value once the current change-detection pass is over: a bound `[multiple]` is written
+     * during change detection, and reporting straight back to the form control there would raise
+     * "Expression has changed after it was checked". Coalesced so that several mode changes in one tick
+     * produce one notification, and dropped if the form writes a value or the tree is gone by the time it runs.
+     */
+    private scheduleValueReport;
+    /** Reports the selection to the form, which then holds it instead of a value still waiting for its nodes. */
+    private reportValue;
+    /** (Re)points the change subscription at the current {@link selectionModel}. */
+    private bindSelectionModel;
+    ngAfterContentInit(): void;
+    /**
+     * Rebuilds the tree around a selection model owned by an embedding host, such as `KbqTreeSelect`.
+     *
+     * The host has to take the model over before the tree starts reacting to it, and re-running
+     * `ngAfterContentInit()` is not a way to do that: neither `unorderedOptions` nor `renderedOptions` is
+     * ever re-created, so a second run would only leave a second set of subscribers on both — every options
+     * change handled twice, and the whole option sweep run twice per emission. Only the subscription that
+     * depends on the model has to move, which is exactly what `bindSelectionModel` does.
+     */
+    initializeForEmbedding(selectionModel: SelectionModel<T>): void;
+    ngAfterContentChecked(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    focus($event: any): void;
+    /** @docs-private */
+    highlightSelectedOption(): void;
+    blur(): void;
+    /**
+     * Host listener for keyboard input.
+     *
+     * Does nothing while an embedding host owns the keyboard — `KbqTreeSelect` routes every key through
+     * its own panel handler and calls back into `handleKeydown` for the parts it delegates, so without
+     * this guard the same event would be acted on twice.
+     */
+    onKeyDown(event: KeyboardEvent): void;
+    /** Runs the tree's own keyboard handling, whether or not it owns the keyboard. */
+    handleKeydown(event: KeyboardEvent): void;
+    /** @docs-private */
+    updateScrollSize(): void;
+    /** @docs-private */
+    setSelectedOptionsByKey(option: KbqTreeOption<T>, shiftKey: boolean, ctrlKey: boolean): void;
+    /** @docs-private */
+    setSelectedOptionsByClick(option: KbqTreeOption<T>, shiftKey: boolean, ctrlKey: boolean): void;
+    /** @docs-private */
+    protected selectActiveOptions(): void;
+    /** @docs-private */
+    protected toggleFocusedOption(): void;
+    /** @docs-private */
+    renderNodeChanges(data: T[] | ReadonlyArray<T>, dataDiffer?: IterableDiffer<T>, viewContainer?: ViewContainerRef, parentData?: T): void;
+    /**
+     * Recomputes every option's checkbox state where no selection change follows to do it: after `dataNodes` is
+     * replaced, which moves the descendants a branch counts, and once a hidden checkbox appears. A microtask later, as
+     * a flat data source assigns `dataNodes` only after it emits.
+     */
+    private scheduleCheckboxSync;
+    /** @docs-private */
+    protected emitNavigationEvent(option: KbqTreeOption<T>): void;
+    /** @docs-private */
+    protected emitChangeEvent(option: KbqTreeOption<T>): void;
+    /** @docs-private */
+    readonly selectAllHandlerInput: _angular_core.InputSignalWithTransform<((event: KeyboardEvent, tree: KbqTreeSelection<T>) => void) | undefined, ((event: KeyboardEvent, tree: KbqTreeSelection<T>) => void) | undefined>;
+    /**
+     * Function for handling the combination Ctrl + A (select all). By default, the internal handler is used,
+     * which toggles the selection of all non-disabled, selectable options.
+     */
+    get selectAllHandler(): (event: KeyboardEvent, tree: KbqTreeSelection<T>) => void;
+    private defaultSelectAllHandler;
+    selectAllOptions(allowDeselect?: boolean): void;
+    copyActiveOption(event: KeyboardEvent): void;
+    writeValue(value: any): void;
+    /** Selects the nodes of a value the form wrote, and keeps the value for the data still to come if any is missing. */
+    private applyWrittenValue;
+    /** Runs a change of the selection made by code, which reports nothing back to the form or to a host. */
+    private syncSelection;
+    /**
+     * Called when the value changes. Needed to properly implement `ControlValueAccessor`.
+     *
+     * @docs-private
+     */
+    onChange: (value: any) => void;
+    registerOnChange(fn: (value: any) => void): void;
+    /**
+     * Called when the control is blurred. Needed to properly implement `ControlValueAccessor`.
+     *
+     * @docs-private
+     */
+    onTouched: () => void;
+    registerOnTouched(fn: () => void): void;
+    /**
+     * Sets the disabled state of the control. Implemented as a part of ControlValueAccessor.
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /** @docs-private */
+    setOptionsFromValues(values: any[]): void;
+    /**
+     * Rebinds orphan node references in selectionModel to current treeControl.dataNodes by value.
+     * Needed after dataSource.data is replaced — selectionModel holds references to old node
+     * objects, but options render with new ones, so toggle()/isSelected() break on identity.
+     *
+     * A value the form wrote ahead of its nodes is applied again instead, which resolves every node anew.
+     * Either way the selection only follows the data, so nothing is reported.
+     */
+    private syncSelectionModelToDataNodes;
+    /** @docs-private */
+    getSelectedValues(): any[];
+    setStateChildren(option: KbqTreeOption<T>, state: boolean): void;
+    private onCopyDefaultHandler;
+    /**
+     * Moves focus to the closest enabled ancestor of the active option — ArrowLeft on a leaf, on an
+     * already-collapsed node, or on a node whose toggle is disabled.
+     *
+     * Ancestors are resolved against `renderedOptions` rather than `treeControl.dataNodes`: every
+     * ancestor of a visible option is itself visible, options are rendered depth-first, and these are
+     * the indices `keyManager` navigates — so the walk starts from `keyManager.activeItemIndex`.
+     * Scanning backwards, the first option with a smaller level is the parent.
+     *
+     * A disabled option cannot take focus (`KbqTreeOption.focus` refuses it), so the walk steps over a
+     * disabled ancestor and narrows `level` to that ancestor's level. Without narrowing, the scan would
+     * continue against the original level and land on a preceding sibling of the parent.
+     */
+    private setActiveParentOption;
+    /** `-1` is the key manager's way of keeping the letter stream running but never matching on it. */
+    private applyTypeAhead;
+    /**
+     * Moves focus to the first child of an already-expanded option — ArrowRight on an expanded node.
+     *
+     * The mirror of `setActiveParentOption`: the first rendered option after the active one is its
+     * first child whenever its level is greater, so nothing has to be re-derived from `treeControl`.
+     * A disabled child cannot take focus, so the walk continues while the options stay inside the
+     * subtree, and stops as soon as the level falls back to the active option's own.
+     */
+    private setActiveFirstChildOption;
+    private getHeight;
+    /** A tree with nothing rendered leaves the tab order, unless a tab index other than `0` is bound. */
+    private updateTabIndex;
+    private updateRenderedOptions;
+    private getSortedNodes;
+    private resetOptions;
+    private dropSubscriptions;
+    private listenToOptionsFocus;
+    /**
+     * Utility to ensure all indexes are valid.
+     *
+     * @param index The index to be checked.
+     * @returns True if the index is valid for our list of options.
+     */
+    private isValidIndex;
+    /** Checks whether any of the options is focused. */
+    private hasFocusedOption;
+    private updateOptionsFocus;
+    private canDeselectLast;
+    private isFocusReceivedFromNestedOption;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTreeSelection<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqTreeSelection<any>, "kbq-tree-selection", ["kbqTreeSelection"], { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "autoSelectInput": { "alias": "autoSelect"; "required": false; "isSignal": true; }; "multipleInput": { "alias": "multiple"; "required": false; "isSignal": true; }; "noUnselectLastInput": { "alias": "noUnselectLast"; "required": false; "isSignal": true; }; "typeAheadInput": { "alias": "typeAhead"; "required": false; "isSignal": true; }; "selectAllToggle": { "alias": "selectAllToggle"; "required": false; "isSignal": true; }; "selectAllInput": { "alias": "selectAll"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "tabIndexInput": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "selectAllHandlerInput": { "alias": "selectAllHandler"; "required": false; "isSignal": true; }; }, { "navigationChange": "navigationChange"; "selectionChangeOutput": "selectionChange"; "selectAllChange": "selectAllChange"; "onSelectAll": "onSelectAll"; "copyChangeOutput": "copyChange"; "onCopyOutput": "onCopy"; }, ["unorderedOptionsQuery"], never, true, [{ directive: typeof i1.KbqStateSaving; inputs: { "useStateSaving": "useStateSaving"; "stateSavingKey": "stateSavingKey"; }; outputs: {}; }, { directive: typeof i1.KbqLocaleOverridesDirective; inputs: { "kbqLocaleOverrides": "localeOverrides"; }; outputs: {}; }]>;
+}
+
+declare class KbqTreeModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTreeModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqTreeModule, never, [typeof i1.KbqPseudoCheckboxModule, typeof i2.KbqIconModule, typeof i1.KbqActionContainer, typeof KbqTreeNodeOutlet, typeof KbqTreeNodeDef, typeof KbqTreeNode, typeof KbqTreeNodePadding, typeof KbqTree, typeof KbqTreeSelection, typeof KbqTreeOption, typeof KbqTreeNodeToggleComponent, typeof KbqTreeNodeToggleDirective], [typeof KbqTreeNodeOutlet, typeof KbqTreeNodeDef, typeof KbqTreeNode, typeof KbqTreeNodePadding, typeof KbqTree, typeof KbqTreeSelection, typeof KbqTreeOption, typeof KbqTreeNodeToggleComponent, typeof KbqTreeNodeToggleDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqTreeModule>;
+}
+
+export { BaseTreeControl, FilterByValues, FilterByViewValue, FilterParentsForNodes, FlatTreeControl, KBQ_SELECTION_TREE_VALUE_ACCESSOR, KBQ_TREE_OPTION_PARENT_COMPONENT, KbqTree, KbqTreeBase, KbqTreeCopyEvent, KbqTreeFlatDataSource, KbqTreeFlattener, KbqTreeModule, KbqTreeNavigationChange, KbqTreeNestedDataSource, KbqTreeNode, KbqTreeNodeDef, KbqTreeNodeOutlet, KbqTreeNodeOutletContext, KbqTreeNodePadding, KbqTreeNodeToggleBaseDirective, KbqTreeNodeToggleComponent, KbqTreeNodeToggleDirective, KbqTreeOption, KbqTreeOptionChange, KbqTreeSelectAllEvent, KbqTreeSelection, KbqTreeSelectionChange, NestedTreeControl, defaultCompareValues, defaultCompareViewValues, kbqTreeSelectAllValue };
+export type { FlatTreeControlFilter, KbqTreeOptionEvent, KbqTreeOptionParent, KbqTreeState, TreeControl };