@koobiq/components 20.4.2 → 21.0.1

package/tree/index.d.ts

@@ -1,802 +0,0 @@
-import { SelectionModel, DataSource, CollectionViewer, SelectionChange } from '@angular/cdk/collections';
-import { BehaviorSubject, Observable, Subject } from 'rxjs';
-import * as i0 from '@angular/core';
-import { TemplateRef, ViewContainerRef, ChangeDetectorRef, AfterContentChecked, OnDestroy, OnInit, IterableDiffers, TrackByFunction, QueryList, IterableDiffer, DestroyRef, ElementRef, AfterViewInit, InjectionToken, AfterContentInit, EventEmitter } from '@angular/core';
-import * as i1 from '@koobiq/components/core';
-import { IFocusableOption, KbqTitleTextRef, KbqPseudoCheckbox, KbqOptionActionComponent, KbqPseudoCheckboxState, FocusKeyManager, 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[];
-}
-declare class FilterByViewValue<T> implements FlatTreeControlFilter<T> {
-    private control;
-    result: T[];
-    constructor(control: FlatTreeControl<T>);
-    handle(value: string | null): T[];
-}
-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;
-    getParents(node: any, 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. */
-    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:
- *   SomeNode: {
- *     key: 'Fruits',
- *     children: [
- *       NodeOne: {
- *         key: 'Apple',
- *       },
- *       NodeTwo: {
- *        key: 'Pear',
- *      }
- *    ]
- *  }
- *  After flattener flatten the tree, the structure will become
- *  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);
-    flattenNode(node: T, level: number, resultNodes: F[], parent: F | null): F[];
-    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 `MсTreeFlattener`, 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 _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: i0.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: i0.ɵɵFactoryDeclaration<KbqTreeNodeDef<any>, never>;
-    static ɵdir: i0.ɵɵ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;
-    changeDetectorRef: ChangeDetectorRef;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeNodeOutlet, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTreeNodeOutlet, "[kbqTreeNodeOutlet]", never, {}, {}, never, never, true, never>;
-}
-
-declare class KbqTreeBase<T> implements AfterContentChecked, CollectionViewer, OnDestroy, OnInit {
-    protected differs: IterableDiffers;
-    protected changeDetectorRef: ChangeDetectorRef;
-    treeControl: TreeControl<T>;
-    /**
-     * 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`.
-     */
-    readonly trackBy: i0.InputSignal<TrackByFunction<T>>;
-    nodeOutlet: KbqTreeNodeOutlet;
-    /** The tree node template for the tree */
-    nodeDefs: QueryList<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.
-     */
-    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;
-    /**
-     * 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[];
-    set dataSource(dataSource: DataSource<T> | Observable<T[]> | T[]);
-    private _dataSource;
-    protected readonly destroyRef: DestroyRef;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    ngAfterContentChecked(): void;
-    /** 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;
-    /**
-     * 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;
-    /** 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;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeBase<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTreeBase<any>, never, never, { "treeControl": { "alias": "treeControl"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "dataSource": { "alias": "dataSource"; "required": false; }; }, {}, ["nodeDefs"], never, true, never>;
-}
-declare class KbqTreeNode<T> implements IFocusableOption, OnDestroy {
-    protected elementRef: ElementRef<HTMLElement>;
-    tree: KbqTreeBase<T>;
-    /**
-     * The most recently created `KbqTreeNode`. We save it in static variable so we can retrieve it
-     * in `KbqTree` and set the data to it.
-     */
-    static mostRecentTreeNode: KbqTreeNode<any> | null;
-    protected destroyed: Subject<void>;
-    get data(): T;
-    set data(value: T);
-    private _data;
-    get isExpanded(): boolean;
-    get level(): number;
-    constructor();
-    ngOnDestroy(): void;
-    focus(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeNode<any>, never>;
-    static ɵdir: i0.ɵɵ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>;
-    private renderer;
-    private element;
-    private option;
-    private dir;
-    get level(): number;
-    set level(value: number);
-    private _level;
-    get indent(): number | string;
-    set indent(indent: number | string);
-    private _indent;
-    get leftPadding(): number;
-    get leftPaddingForFirstLevel(): number;
-    /** CSS units used for the indentation value. */
-    indentUnits: string;
-    withIcon: boolean;
-    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.
-     * @docs-private
-     */
-    private setLevelInput;
-    /**
-     * 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.
-     * @docs-private
-     */
-    private setIndentInput;
-    private setPadding;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeNodePadding<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTreeNodePadding<any>, "[kbqTreeNodePadding]", ["kbqTreeNodePadding"], { "indent": { "alias": "kbqTreeNodePaddingIndent"; "required": false; }; }, {}, never, never, true, never>;
-}
-
-/** @docs-private */
-declare class KbqTreeNodeToggleBaseDirective<T> {
-    private tree;
-    private treeNode;
-    readonly node: i0.InputSignal<T>;
-    get recursive(): boolean;
-    set recursive(value: any);
-    private _recursive;
-    get disabled(): boolean;
-    set disabled(value: boolean);
-    private _disabled;
-    get iconState(): boolean;
-    constructor();
-    toggle(event: Event): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeNodeToggleBaseDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTreeNodeToggleBaseDirective<any>, never, never, { "node": { "alias": "node"; "required": false; "isSignal": true; }; "recursive": { "alias": "kbqTreeNodeToggleRecursive"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
-    static ngAcceptInputType_disabled: unknown;
-}
-declare class KbqTreeNodeToggleComponent<T> extends KbqTreeNodeToggleBaseDirective<T> {
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeNodeToggleComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTreeNodeToggleComponent<any>, "kbq-tree-node-toggle", ["kbqTreeNodeToggle"], {}, {}, never, ["*"], true, never>;
-}
-declare class KbqTreeNodeToggleDirective<T> extends KbqTreeNodeToggleBaseDirective<T> {
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeNodeToggleDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTreeNodeToggleDirective<any>, "[kbq-tree-node-toggle], [kbqTreeNodeToggle]", ["kbqTreeNodeToggle"], {}, {}, never, never, true, never>;
-}
-
-declare class KbqTree extends KbqTreeBase<any> {
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTree, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTree, "kbq-tree", ["kbqTree"], {}, {}, never, never, true, never>;
-}
-
-interface KbqTreeOptionEvent {
-    option: KbqTreeOption;
-}
-/** Injection token used to provide the parent component to options. */
-declare const KBQ_TREE_OPTION_PARENT_COMPONENT: InjectionToken<any>;
-/**
- * Represents a change event for a tree option.
- *
- * @param source - The tree option that has been modified or selected.
- * @param isUserInput - DEPRECATED Will be removed in version 20.
- */
-declare class KbqTreeOptionChange {
-    source: KbqTreeOption;
-    isUserInput: boolean;
-    constructor(source: KbqTreeOption, isUserInput?: boolean);
-}
-declare class KbqTreeOption extends KbqTreeNode<KbqTreeOption> implements AfterContentInit, KbqTitleTextRef {
-    private changeDetectorRef;
-    private ngZone;
-    private readonly destroyRef;
-    tree: any;
-    readonly onFocus: Subject<KbqTreeOptionEvent>;
-    readonly onBlur: Subject<KbqTreeOptionEvent>;
-    preventBlur: boolean;
-    parentTextElement: ElementRef;
-    get textElement(): ElementRef;
-    readonly toggleElementDirective: i0.Signal<KbqTreeNodeToggleDirective<any> | undefined>;
-    readonly toggleElementComponent: i0.Signal<KbqTreeNodeToggleComponent<any> | undefined>;
-    readonly pseudoCheckbox: i0.Signal<KbqPseudoCheckbox | undefined>;
-    readonly actionButton: i0.Signal<KbqOptionActionComponent | undefined>;
-    tooltipTrigger?: KbqTooltipTrigger;
-    dropdownTrigger?: KbqDropdownTrigger;
-    readonly checkboxThirdState: i0.InputSignal<boolean>;
-    get externalPseudoCheckbox(): boolean;
-    get value(): any;
-    set value(value: any);
-    private _value;
-    get disabled(): any;
-    set disabled(value: any);
-    private _disabled;
-    /**
-     * 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: i0.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: i0.InputSignalWithTransform<boolean, unknown>;
-    get showCheckbox(): any;
-    set showCheckbox(value: any);
-    private _showCheckbox;
-    readonly onSelectionChange: i0.OutputEmitterRef<KbqTreeOptionChange>;
-    readonly userInteraction: EventEmitter<void>;
-    get selected(): boolean;
-    set selected(value: boolean);
-    private _selected;
-    get id(): string;
-    private _id;
-    get viewValue(): string;
-    hasFocus: boolean;
-    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<KbqTreeOption> | undefined;
-    get isToggleInDefaultPlace(): boolean;
-    checkboxState: KbqPseudoCheckboxState;
-    constructor();
-    ngAfterContentInit(): void;
-    descendantsAllSelected(): boolean;
-    descendantsPartiallySelected(): boolean;
-    updateParentsCheckboxState(node: any): void;
-    updateCheckboxState: () => void;
-    toggle(): void;
-    setSelected(selected: boolean): void;
-    focus(focusOrigin?: FocusOrigin): void;
-    blur(): void;
-    /** @docs-private */
-    getHeight(): number;
-    select(setFocus?: boolean): void;
-    deselect(): void;
-    onKeydown($event: any): void;
-    selectViaInteraction($event?: KeyboardEvent): void;
-    emitSelectionChangeEvent(): void;
-    getHostElement(): HTMLElement;
-    markForCheck(): void;
-    /** @docs-private */
-    protected onMouseenter(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeOption, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTreeOption, "kbq-tree-option", ["kbqTreeOption"], { "checkboxThirdState": { "alias": "checkboxThirdState"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selectAllRow": { "alias": "selectAllRow"; "required": false; "isSignal": true; }; "showCheckbox": { "alias": "showCheckbox"; "required": false; }; }, { "onSelectionChange": "onSelectionChange"; }, ["toggleElementDirective", "toggleElementComponent", "pseudoCheckbox", "actionButton", "tooltipTrigger", "dropdownTrigger"], ["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: any;
-declare class KbqTreeSelectAllEvent<T> {
-    source: KbqTreeSelection;
-    options: T[];
-    constructor(source: KbqTreeSelection, 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> {
-    source: KbqTreeSelection;
-    option: T;
-    event?: KeyboardEvent | undefined;
-    constructor(source: KbqTreeSelection, option: T, event?: KeyboardEvent | undefined);
-}
-declare class KbqTreeNavigationChange<T> {
-    source: KbqTreeSelection;
-    option: T;
-    constructor(source: KbqTreeSelection, option: T);
-}
-declare class KbqTreeSelectionChange<T> {
-    source: KbqTreeSelection;
-    option: T;
-    options?: T[] | undefined;
-    constructor(source: KbqTreeSelection, option: T, options?: T[] | undefined);
-}
-interface SelectionModelOption {
-    id: number | string;
-    value: string;
-}
-declare class KbqTreeSelection extends KbqTreeBase<any> implements ControlValueAccessor, AfterContentInit, AfterViewInit, OnDestroy {
-    private elementRef;
-    private scheduler;
-    private clipboard;
-    private readonly platform;
-    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>;
-    keyManager: FocusKeyManager<KbqTreeOption>;
-    selectionModel: SelectionModel<SelectionModelOption>;
-    resetFocusedItemOnBlur: boolean;
-    multipleMode: MultipleMode | null;
-    userTabIndex: number | null;
-    optionShouldHoldFocusOnBlur: boolean;
-    nodeOutlet: KbqTreeNodeOutlet;
-    /** Reference to the built-in "select all" row, rendered only while `selectAll` is on. */
-    readonly selectAllOption: i0.Signal<KbqTreeOption | undefined>;
-    unorderedOptions: QueryList<KbqTreeOption>;
-    treeControl: FlatTreeControl<any>;
-    readonly navigationChange: i0.OutputEmitterRef<KbqTreeNavigationChange<KbqTreeOption>>;
-    readonly selectionChange: EventEmitter<KbqTreeSelectionChange<KbqTreeOption>>;
-    readonly onSelectAll: i0.OutputEmitterRef<KbqTreeSelectAllEvent<KbqTreeOption>>;
-    readonly onCopy: EventEmitter<KbqTreeCopyEvent<KbqTreeOption>>;
-    private sortedNodes;
-    private lastSyncedDataNodes;
-    get autoSelect(): boolean;
-    set autoSelect(value: boolean);
-    private _autoSelect;
-    get optionFocusChanges(): Observable<KbqTreeOptionEvent>;
-    get optionBlurChanges(): Observable<KbqTreeOptionEvent>;
-    get multiple(): boolean;
-    get noUnselectLast(): boolean;
-    set noUnselectLast(value: boolean);
-    private _noUnselectLast;
-    /** When `true`, a repeated Ctrl/Cmd+A deselects all options. Off by default (Ctrl+A only selects). */
-    readonly selectAllToggle: i0.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);
-    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. Kept in step with the locale service. */
-    protected selectAllText: string;
-    /**
-     * 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();
-    get disabled(): boolean;
-    set disabled(rawValue: boolean);
-    private _disabled;
-    get tabIndex(): any;
-    set tabIndex(value: any);
-    private _tabIndex;
-    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 readonly localeService?;
-    /** Updates locale parameters from the locale service. */
-    private updateLocaleParams;
-    constructor();
-    /** Selects every node "select all" can act on, or deselects them all when they are already selected. */
-    protected toggleSelectAll(): void;
-    ngAfterContentInit(): void;
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-    focus($event: any): void;
-    highlightSelectedOption(): void;
-    blur(): void;
-    onKeyDown(event: KeyboardEvent): void;
-    updateScrollSize(): void;
-    setSelectedOptionsByKey(option: KbqTreeOption, shiftKey: boolean, ctrlKey: boolean): void;
-    setSelectedOptionsByClick(option: KbqTreeOption, shiftKey: boolean, ctrlKey: boolean): void;
-    selectActiveOptions(): void;
-    setFocusedOption(option: KbqTreeOption): void;
-    toggleFocusedOption(): void;
-    renderNodeChanges(data: KbqTreeOption[], dataDiffer?: IterableDiffer<KbqTreeOption>, viewContainer?: ViewContainerRef, parentData?: KbqTreeOption): void;
-    emitNavigationEvent(option: KbqTreeOption): void;
-    emitChangeEvent(option: KbqTreeOption): void;
-    /**
-     * 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) => void;
-    set selectAllHandler(fn: (event: KeyboardEvent, tree: KbqTreeSelection) => void);
-    private _selectAllHandler;
-    selectAllOptions(allowDeselect?: boolean): void;
-    copyActiveOption(event: KeyboardEvent): void;
-    writeValue(value: any): void;
-    /** `View -> model callback called when value changes` */
-    onChange: (value: any) => void;
-    registerOnChange(fn: (value: any) => void): void;
-    /** `View -> model callback called when select has been touched` */
-    onTouched: () => void;
-    registerOnTouched(fn: () => {}): void;
-    /**
-     * Sets the disabled state of the control. Implemented as a part of ControlValueAccessor.
-     */
-    setDisabledState(isDisabled: boolean): void;
-    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.
-     */
-    private syncSelectionModelToDataNodes;
-    getSelectedValues(): any[];
-    getItemHeight(): number;
-    setStateChildren(option: KbqTreeOption, 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;
-    private getHeight;
-    private updateTabIndex;
-    private updateRenderedOptions;
-    private getSortedNodes;
-    private allowFocusEscape;
-    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 markOptionsForCheck;
-    private updateOptionsFocus;
-    private canDeselectLast;
-    private isFocusReceivedFromNestedOption;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeSelection, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTreeSelection, "kbq-tree-selection", ["kbqTreeSelection"], { "treeControl": { "alias": "treeControl"; "required": false; }; "autoSelect": { "alias": "autoSelect"; "required": false; }; "noUnselectLast": { "alias": "noUnselectLast"; "required": false; }; "selectAllToggle": { "alias": "selectAllToggle"; "required": false; "isSignal": true; }; "selectAll": { "alias": "selectAll"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "selectAllHandler": { "alias": "selectAllHandler"; "required": false; }; }, { "navigationChange": "navigationChange"; "selectionChange": "selectionChange"; "onSelectAll": "onSelectAll"; "onCopy": "onCopy"; }, ["unorderedOptions"], never, true, never>;
-    static ngAcceptInputType_selectAll: unknown;
-}
-
-declare class KbqTreeModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeModule, never>;
-    static ɵmod: i0.ɵɵ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: i0.ɵɵ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, TreeControl };