@koobiq/components 19.8.0 → 20.0.0

package/tree/index.d.ts

@@ -1 +1,718 @@
-export * from './public-api';
+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, OnDestroy, ElementRef, AfterContentChecked, OnInit, IterableDiffers, TrackByFunction, QueryList, IterableDiffer, DestroyRef, AfterViewInit, AfterContentInit, EventEmitter, InjectionToken } 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;
+    tree: any;
+    readonly onFocus: Subject<KbqTreeOptionEvent>;
+    readonly onBlur: Subject<KbqTreeOptionEvent>;
+    preventBlur: boolean;
+    parentTextElement: 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>;
+    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;
+    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; }; "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;
+    protected readonly focusMonitor: FocusMonitor;
+    /** Indicates whether this component is placed inside a KbqFormField component. */
+    protected readonly inSelect: boolean;
+    renderedOptions: QueryList<KbqTreeOption>;
+    keyManager: FocusKeyManager<KbqTreeOption>;
+    selectionModel: SelectionModel<SelectionModelOption>;
+    resetFocusedItemOnBlur: boolean;
+    multipleMode: MultipleMode | null;
+    userTabIndex: number | null;
+    optionShouldHoldFocusOnBlur: boolean;
+    nodeOutlet: KbqTreeNodeOutlet;
+    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;
+    get disabled(): boolean;
+    set disabled(rawValue: boolean);
+    private _disabled;
+    get tabIndex(): any;
+    set tabIndex(value: any);
+    private _tabIndex;
+    get showCheckbox(): boolean;
+    get isEmpty(): boolean;
+    private optionFocusSubscription;
+    private optionBlurSubscription;
+    constructor();
+    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;
+    selectAllOptions(): 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;
+    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; }; "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; }, { "navigationChange": "navigationChange"; "selectionChange": "selectionChange"; "onSelectAll": "onSelectAll"; "onCopy": "onCopy"; }, ["unorderedOptions"], never, true, never>;
+}
+
+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 };