@koobiq/components 20.4.2 → 21.0.0

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

@@ -0,0 +1,667 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, AfterViewChecked, AfterContentInit, AfterViewInit, OnDestroy, OnInit, DoCheck, ElementRef, ChangeDetectorRef, QueryList, TemplateRef, InputSignal, EventEmitter, Provider } from '@angular/core';
+import { SelectionModel } from '@angular/cdk/collections';
+import * as i1 from '@angular/cdk/overlay';
+import { ScrollStrategy, ConnectedPosition, CdkConnectedOverlay, CdkOverlayOrigin } from '@angular/cdk/overlay';
+import { ControlValueAccessor, NgForm, FormGroupDirective, NgControl } from '@angular/forms';
+import * as i4 from '@koobiq/components/core';
+import { KbqPanelWidth, KbqPanelMinWidth, KbqPanelMaxWidth, KbqPanelMaxHeight, KbqAbstractSelect, CanUpdateErrorState, KbqSiblingPopup, ErrorStateMatcher, KbqSelectTrigger, KbqSelectMatcher, KbqSelectSearch, KbqSelectAllEvent, KbqComponentColors } from '@koobiq/components/core';
+import * as i7 from '@koobiq/components/form-field';
+import { KbqFormFieldControl, KbqCleaner } from '@koobiq/components/form-field';
+import * as i3 from '@koobiq/components/tags';
+import { KbqTag } from '@koobiq/components/tags';
+import * as i2 from '@koobiq/components/tree';
+import { KbqTreeOption, KbqTreeSelection } from '@koobiq/components/tree';
+import { Subject, Observable } from 'rxjs';
+import * as i5 from '@koobiq/components/select';
+
+/** Tree select trigger value type. */
+type KbqTreeSelectTriggerValue = {
+    disabled: boolean;
+    value: string;
+    viewValue: string;
+};
+/**
+ * Orders the values of a tree select in multiple mode, as `Array.prototype.sort` does. Receives two selected data
+ * nodes and every data node of the tree in panel order.
+ */
+type KbqTreeSelectSortComparator<T = any> = (a: T, b: T, nodes: T[]) => number;
+/** Options for the `kbq-tree-select` that can be configured using the `KBQ_TREE_SELECT_OPTIONS` injection token. */
+type KbqTreeSelectOptions = Partial<{
+    /**
+     * Width of the panel. If set to `auto`, the panel will match the trigger width.
+     * If set to null or an empty string, the panel will grow to match the longest option's text.
+     */
+    panelWidth: KbqPanelWidth;
+    /**
+     * Minimum width of the panel. If minWidth is larger than window width or property set to null, it will be ignored.
+     */
+    panelMinWidth: KbqPanelMinWidth;
+    /**
+     * Maximum width of the panel. Caps growth by content only — it never overrides the trigger width or an
+     * explicit `panelWidth`. If null, the `--kbq-panel-size-width-max` token applies.
+     */
+    panelMaxWidth: KbqPanelMaxWidth;
+    /**
+     * Maximum height of the panel's scrollable option list. Does not include the search field or the
+     * footer. If null, the `--kbq-select-panel-size-max-height` token applies.
+     */
+    panelMaxHeight: KbqPanelMaxHeight;
+    /**
+     * Whether to enable hiding search by default if options is less than minimum.
+     *
+     * - `'auto'` uses {@link KBQ_SELECT_SEARCH_MIN_OPTIONS_THRESHOLD} as min value.
+     * - number - will enables search hiding and uses value as min.
+     */
+    searchMinOptionsThreshold: 'auto' | number;
+    /**
+     * Decides which selected nodes the projected `KbqCleaner` removes. Disabled nodes are kept when this
+     * is not set. Overridden per instance by the `clearPredicate` attribute.
+     */
+    clearPredicate: (node: any) => boolean;
+}>;
+/** Injection token that can be used to provide the default options for the `kbq-tree-select`. */
+declare const KBQ_TREE_SELECT_OPTIONS: InjectionToken<Partial<{
+    /**
+     * Width of the panel. If set to `auto`, the panel will match the trigger width.
+     * If set to null or an empty string, the panel will grow to match the longest option's text.
+     */
+    panelWidth: KbqPanelWidth;
+    /**
+     * Minimum width of the panel. If minWidth is larger than window width or property set to null, it will be ignored.
+     */
+    panelMinWidth: KbqPanelMinWidth;
+    /**
+     * Maximum width of the panel. Caps growth by content only — it never overrides the trigger width or an
+     * explicit `panelWidth`. If null, the `--kbq-panel-size-width-max` token applies.
+     */
+    panelMaxWidth: KbqPanelMaxWidth;
+    /**
+     * Maximum height of the panel's scrollable option list. Does not include the search field or the
+     * footer. If null, the `--kbq-select-panel-size-max-height` token applies.
+     */
+    panelMaxHeight: KbqPanelMaxHeight;
+    /**
+     * Whether to enable hiding search by default if options is less than minimum.
+     *
+     * - `'auto'` uses {@link KBQ_SELECT_SEARCH_MIN_OPTIONS_THRESHOLD} as min value.
+     * - number - will enables search hiding and uses value as min.
+     */
+    searchMinOptionsThreshold: "auto" | number;
+    /**
+     * Decides which selected nodes the projected `KbqCleaner` removes. Disabled nodes are kept when this
+     * is not set. Overridden per instance by the `clearPredicate` attribute.
+     */
+    clearPredicate: (node: any) => boolean;
+}>>;
+/** Utility provider for `KBQ_TREE_SELECT_OPTIONS`. */
+declare const kbqTreeSelectOptionsProvider: (options: KbqTreeSelectOptions) => Provider;
+/** Change event object that is emitted when the select value has changed. */
+declare class KbqTreeSelectChange<T = any> {
+    /** Select the change comes from. */
+    source: KbqTreeSelect;
+    /**
+     * Option the change is about — a `KbqTreeOption` whenever the changed node is rendered, and the
+     * raw value of the node when it is not. `null` when the change is not about a single option,
+     * which today means the cleaner was activated; `values` then carries the nodes it removed.
+     */
+    value: T;
+    /** Whether the change was made by the user rather than written to the model. */
+    isUserInput: boolean;
+    /** Every option the change is about, when it covers more than one. */
+    values?: unknown[] | undefined;
+    constructor(
+    /** Select the change comes from. */
+    source: KbqTreeSelect, 
+    /**
+     * Option the change is about — a `KbqTreeOption` whenever the changed node is rendered, and the
+     * raw value of the node when it is not. `null` when the change is not about a single option,
+     * which today means the cleaner was activated; `values` then carries the nodes it removed.
+     */
+    value: T, 
+    /** Whether the change was made by the user rather than written to the model. */
+    isUserInput?: boolean, 
+    /** Every option the change is about, when it covers more than one. */
+    values?: unknown[] | undefined);
+}
+declare class KbqTreeSelect<T = any> extends KbqAbstractSelect implements AfterViewChecked, AfterContentInit, AfterViewInit, OnDestroy, OnInit, DoCheck, ControlValueAccessor, KbqFormFieldControl<KbqTreeOption>, CanUpdateErrorState, KbqSiblingPopup {
+    elementRef: ElementRef<HTMLElement>;
+    protected readonly changeDetectorRef: ChangeDetectorRef;
+    private readonly injector;
+    private readonly renderer;
+    defaultErrorStateMatcher: ErrorStateMatcher;
+    private readonly scrollStrategyFactory;
+    private readonly overlayLayers;
+    parentForm: NgForm | null;
+    parentFormGroup: FormGroupDirective | null;
+    private readonly parentFormField;
+    ngControl: NgControl | null;
+    protected readonly isBrowser: boolean;
+    private readonly defaultOptions;
+    private readonly errorStateTracker;
+    /** Whether the component is in an error state. */
+    readonly errorState: _angular_core.Signal<boolean>;
+    /** A name for this control that can be used by `kbq-form-field`. */
+    controlType: string;
+    /**
+     * A `kbq-tree-select` is not a native labelable element, so the form-field's `<label for>` cannot
+     * associate with it. The control is named through `aria-labelledby` instead.
+     */
+    readonly isNativeLabelSupported = false;
+    /** Number of the selected items that do not fit into the trigger. */
+    readonly hiddenItems: _angular_core.WritableSignal<number>;
+    /** The last measured value for the trigger's client bounding rect. */
+    protected triggerRect: DOMRect;
+    /** The cached font-size of the trigger element. */
+    triggerFontSize: number;
+    /**
+     * Deals with the selection logic. The projected `kbq-tree-selection` shares the same instance.
+     *
+     * `T` is the type of the data nodes, the same as the projected tree's. A template infers it from `[clearPredicate]`
+     * alone, apart from the tree; a query names it: `viewChild.required<KbqTreeSelect<Node>>(KbqTreeSelect)`.
+     */
+    selectionModel: SelectionModel<T>;
+    /** Emits once the panel has rendered (`'showing'`) or has been removed (`'void'`). */
+    protected readonly panelDoneAnimatingStream: Subject<string>;
+    private panelRender?;
+    /** Strategy that will be used to handle scrolling while the select panel is open. */
+    scrollStrategy: ScrollStrategy;
+    /**
+     * Minimum space to keep between the overlay and the viewport edge.
+     * At least `defaultOffsetY` so CDK's fit check — which runs before the `kbq-connected-overlay_below/_above`
+     * gap padding is applied to the pane — stays conservative enough to absorb that padding instead of
+     * letting the panel overflow the viewport by the size of the gap.
+     */
+    protected readonly viewportMargin: number;
+    /**
+     * Opens the panel below the trigger, falling back to above it when it does not fit.
+     *
+     * A third position is appended at runtime by `updatePanelAnchor`: a multiline trigger that has grown
+     * taller than the panel gets it anchored to its first row and drawn over the rest of it.
+     */
+    positions: ConnectedPosition[];
+    protected options: QueryList<KbqTreeOption<T>>;
+    /**
+     * Trigger - is a clickable field to open select dropdown panel
+     */
+    readonly trigger: _angular_core.Signal<ElementRef<any>>;
+    /** Reference to the overlay panel element. */
+    readonly panel: _angular_core.Signal<ElementRef<any> | undefined>;
+    /** Scrollable option list inside the panel. */
+    protected readonly optionsContainer: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    /** The options container's custom scrollbar viewport, flashed when the panel opens. */
+    private readonly scrollbarViewport;
+    private readonly overlayDirQuery;
+    /** Reference to the CDK connected overlay directive. */
+    protected get overlayDir(): CdkConnectedOverlay;
+    private readonly tagsQuery;
+    private readonly tagsList;
+    protected get tags(): QueryList<KbqTag>;
+    /**
+     * Reference to the optional cleaner element for clearing selection.
+     *
+     * @docs-private
+     */
+    readonly cleaner: _angular_core.Signal<KbqCleaner | undefined>;
+    /** User-supplied override of the trigger element. */
+    readonly customTrigger: _angular_core.Signal<KbqSelectTrigger | undefined>;
+    readonly customMatcher: _angular_core.Signal<KbqSelectMatcher | undefined>;
+    readonly customTagTemplateRef: _angular_core.Signal<TemplateRef<any> | undefined>;
+    readonly tree: _angular_core.Signal<KbqTreeSelection<T> | undefined>;
+    readonly search: _angular_core.Signal<KbqSelectSearch | undefined>;
+    /** Message projected for an empty tree — the only thing the panel opens onto without options. */
+    private readonly noOptionsMessage;
+    /**
+     * Text of the counter of the selected items that do not fit into the trigger. `{{ number }}` is
+     * replaced with their number.
+     *
+     * Left unset, the text follows the active locale (`select.hiddenItemsText`); set, it wins over the
+     * locale and survives a locale change.
+     */
+    readonly hiddenItemsText: InputSignal<string | undefined>;
+    /** Formats the counter of the items that do not fit into the trigger. */
+    readonly hiddenItemsTextFormatter: InputSignal<(hiddenItemsText: string, hiddenItems: number) => string>;
+    private readonly localeConfiguration;
+    /**
+     * Event emitted when the select panel has been toggled.
+     * Also serves as the `openedChange` member of the `KbqSiblingPopup` contract — a tooltip sharing
+     * this element's host reacts to it, so its emission timing (gated on `panelDoneAnimatingStream`, see
+     * `ngOnInit`) matters beyond this output's original consumers.
+     */
+    readonly openedChange: EventEmitter<boolean>;
+    /** @docs-private */
+    readonly openedChangeOutput: _angular_core.OutputRef<boolean>;
+    /** Event emitted when the select has been opened. */
+    readonly openedStream: Observable<void>;
+    /** @docs-private */
+    readonly openedOutput: _angular_core.OutputRef<void>;
+    /** Event emitted when the select has been closed. */
+    readonly closedStream: Observable<void>;
+    /** @docs-private */
+    readonly closedOutput: _angular_core.OutputRef<void>;
+    /** Event emitted when the selected value has been changed by the user. */
+    readonly selectionChange: _angular_core.OutputEmitterRef<KbqTreeSelectChange<any>>;
+    /**
+     * Event emitted whenever the tree's `selectAllOptions()` runs — a click on the `selectAll` master
+     * checkbox, the Ctrl/Cmd + A shortcut, or a custom `selectAllHandler` that delegates to it.
+     */
+    readonly onSelectAll: _angular_core.OutputEmitterRef<KbqSelectAllEvent<KbqTreeOption<T>, KbqTreeSelect<T>>>;
+    /** Classes to be passed to the select panel. Supports the same syntax as the `[class]` binding. */
+    readonly panelClass: InputSignal<string | string[] | Set<string> | {
+        [key: string]: any;
+    }>;
+    readonly backdropClass: InputSignal<string>;
+    /**
+     * Name of the control, for when no element on the page carries it. Defaults to the placeholder.
+     *
+     * Prefer `aria-labelledby` and point it at visible text: a name that duplicates a visible label is one
+     * more string to keep in sync, and a name with no visible counterpart cannot be spoken back by voice
+     * control (WCAG 2.5.3).
+     */
+    readonly ariaLabel: InputSignal<string | null>;
+    /**
+     * Id of the element that names the control. Defaults to the `kbq-label` of a wrapping `kbq-form-field`.
+     *
+     * A `role="combobox"` element takes its name from the author only, so neither the placeholder nor the
+     * selected values name it, and the `<label for>` of the form field names labelable elements only, which
+     * a custom control is not. Without a form-field label, point this at whatever visible text names the
+     * control.
+     */
+    readonly ariaLabelledby: InputSignal<string | null>;
+    /** Object used to control when error messages are shown. */
+    readonly errorStateMatcher: InputSignal<ErrorStateMatcher | undefined>;
+    /**
+     * Function used to sort the values in a select in multiple mode, by default their order in the panel.
+     * Follows the same logic as `Array.prototype.sort`. Receives two selected data nodes and every data node of the
+     * tree in panel order, collapsed branches included — a node in a collapsed branch has no option.
+     */
+    readonly sortComparator: InputSignal<KbqTreeSelectSortComparator>;
+    /**
+     * Decides which selected nodes the projected `KbqCleaner` removes: return `true` to clear the node,
+     * `false` to keep it. Receives the data node, not the option — a node in a collapsed branch has no
+     * option. Disabled nodes are kept by default. Bind a stable reference — a new function on every
+     * change detection re-runs the predicate over the whole selection.
+     *
+     * Not consulted by `writeValue` / `reset()`, which always clear everything. The parameter type becomes the select's
+     * `T` in a template: type it with the tree's node, not with an option.
+     */
+    readonly clearPredicate: _angular_core.InputSignalWithTransform<(node: T) => boolean, (node: T) => boolean>;
+    /**
+     * Whether to use a multiline matcher or not. Default is false
+     */
+    readonly multiline: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Combined stream of all of the child options' change events. */
+    readonly optionSelectionChanges: Observable<KbqTreeSelectChange>;
+    /** Combined stream of all of the child options userInteraction events. */
+    readonly userInteractionChanges: Observable<void>;
+    /** Emits once `options` is assigned, for subscribers that arrive before the content is resolved. */
+    private readonly optionsInitialized;
+    /** Placeholder shown in the trigger while nothing is selected. */
+    readonly placeholder: InputSignal<string | undefined>;
+    /** Whether the select is required. */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly multipleInput: _angular_core.InputSignalWithTransform<boolean, string | boolean | null | undefined>;
+    /** Whether multiple nodes can be selected. Cannot be changed once the selection model exists. */
+    get multiple(): boolean;
+    /** The multiplicity the selection model was created with; a later binding change is refused. */
+    private multipleValue;
+    /** @docs-private */
+    readonly autoSelectInput: _angular_core.InputSignalWithTransform<boolean, string | boolean | null | undefined>;
+    /** Whether moving the active node selects it. Always off in multiple selection. */
+    get autoSelect(): boolean;
+    /** 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 tree. Multiple selection only.
+     *
+     * The row acts on the nodes the user can actually toggle — enabled and selectable. Without a search
+     * query that covers the whole data set, collapsed branches included; while a query is active it
+     * covers only the matches. Enabling it also makes Ctrl/Cmd + A a two-way toggle, so the shortcut and
+     * the checkbox never disagree (`selectAllToggle` is implied).
+     */
+    readonly selectAll: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly valueState;
+    /** Values of the selected nodes: an array in multiple mode. */
+    readonly value: _angular_core.Signal<any>;
+    /** @docs-private */
+    readonly idInput: InputSignal<string | undefined>;
+    /** Unique identifier of the select, generated when not provided. */
+    readonly id: _angular_core.Signal<string>;
+    /** Whether the overlay panel is rendered on top of a backdrop. */
+    readonly hasBackdrop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** @docs-private */
+    readonly tabIndexInput: InputSignal<number | null>;
+    /** Tab index of the select, `-1` while it is disabled. A value that is not an integer keeps the last valid one. */
+    get tabIndex(): number | null;
+    private readonly validTabIndex;
+    /** @docs-private */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, string | boolean | null | undefined>;
+    /** Whether the select is disabled. Also set by the bound form control. */
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    private readonly resolvedTabIndex;
+    private readonly resolvedAriaLabel;
+    /** @docs-private */
+    readonly selectAllHandlerInput: _angular_core.InputSignalWithTransform<((event: KeyboardEvent, select: KbqTreeSelect<T>) => void) | undefined, ((event: KeyboardEvent, select: KbqTreeSelect<T>) => void) | undefined>;
+    /**
+     * Function for handling the combination Ctrl + A (select all). By default, the internal handler is used.
+     */
+    get selectAllHandler(): (event: KeyboardEvent, select: KbqTreeSelect<T>) => void;
+    /** Function for handling the combination Ctrl + A (select all). By default, the internal handler is used. */
+    private defaultSelectAllHandler;
+    private readonly focusedValue;
+    private readonly panelOpenValue;
+    /** Whether the select is focused. */
+    readonly focused: _angular_core.Signal<boolean>;
+    /** Whether multiple choice is enabled or not. True if multiple or multiline */
+    get multiSelection(): boolean;
+    /**
+     * Minimum width of the panel.
+     * If minWidth is larger than window width, it will be ignored.
+     */
+    readonly panelMinWidth: _angular_core.InputSignalWithTransform<KbqPanelMinWidth, unknown>;
+    /** Origin for the overlay panel. */
+    protected overlayOrigin?: CdkOverlayOrigin | ElementRef;
+    /**
+     * Width of the panel. If set to `auto`, the panel will match the trigger width, but will never be
+     * narrower than `panelMinWidth`. If set to null or an empty string, the panel will grow to match the
+     * longest option's text. Any other value is used as an exact width, and `panelMinWidth` is not applied.
+     */
+    readonly panelWidth: InputSignal<KbqPanelWidth>;
+    /**
+     * Maximum width of the panel in pixels. Caps how far the panel grows with its content — it never makes
+     * the panel narrower than the trigger, and never clamps an explicit `panelWidth`.
+     * When null, the `--kbq-panel-size-width-max` token applies.
+     */
+    readonly panelMaxWidth: _angular_core.InputSignalWithTransform<KbqPanelMaxWidth, unknown>;
+    /**
+     * Maximum height of the panel's scrollable option list, in pixels. Applied as the
+     * `--kbq-select-panel-size-max-height` custom property on the panel.
+     *
+     * The search field and the footer sit outside the scrollable area and add to the panel's total height.
+     * When null, the token default (256px) applies.
+     */
+    readonly panelMaxHeight: _angular_core.InputSignalWithTransform<KbqPanelMaxHeight, unknown>;
+    /**
+     * `panelMaxHeight` rendered as a CSS length for the `--kbq-select-panel-size-max-height` token.
+     * A non-finite value (e.g. `null`) leaves the stylesheet default in place.
+     *
+     * @docs-private
+     */
+    protected readonly panelMaxHeightToken: _angular_core.Signal<string | null>;
+    /**
+     * Controls when the search functionality is displayed based on the number of available options.
+     *
+     * Automatically enables search hiding if value provided, even if `defaultOptions.searchMinOptionsThreshold` is provided.
+     * Defaults to `undefined`.
+     */
+    readonly searchMinOptionsThreshold: _angular_core.Signal<number | undefined>;
+    /** @docs-private */
+    readonly searchMinOptionsThresholdInput: InputSignal<number | "auto" | undefined>;
+    get panelOpen(): boolean;
+    /** Whether the overlay panel is currently on screen. Part of the `KbqSiblingPopup` contract. */
+    get isAttached(): boolean;
+    /**
+     * Whether the cleaner (clear button) should be shown.
+     *
+     * @docs-private
+     */
+    get canShowCleaner(): boolean;
+    /**
+     * Whether the cleaner still has a node to remove.
+     *
+     * @docs-private
+     */
+    get canClear(): boolean;
+    /** Selected nodes the cleaner removes, in selection order. */
+    private get clearTargets();
+    /**
+     * The tree answers for any node; the option is asked only for its own `[disabled]` input, and a
+     * node inside a collapsed branch has no option to ask.
+     */
+    private isNodeDisabled;
+    /**
+     * Colour of the trigger's tags and arrow.
+     *
+     * @docs-private
+     */
+    readonly colorForState: _angular_core.Signal<KbqComponentColors>;
+    /** Full set of classes for the panel: base class, form-field theme and custom `panelClass`. */
+    protected readonly panelClasses: _angular_core.Signal<string>;
+    /** Text of the counter of the items that do not fit into the trigger. */
+    protected readonly hiddenItemsLabel: _angular_core.Signal<string>;
+    /**
+     * Accessible name of the combobox.
+     *
+     * A combobox takes its name from the author only, so the placeholder rendered inside the trigger does
+     * not name it. Falling back to the placeholder text keeps a control that was given neither an
+     * `aria-label` nor an `aria-labelledby` from being announced blank — the shape every consumer in the
+     * repository is in. Left off while `aria-labelledby` is set, which outranks `aria-label` anyway.
+     */
+    protected get ariaLabelText(): string | null;
+    isEmptySearchResult: boolean;
+    triggerValues: KbqTreeSelectTriggerValue[];
+    private closeSubscription;
+    /** The scroll offset the panel is restored to when it attaches — the list always opens at the top. */
+    private scrollTop;
+    /** Unique id for this input. */
+    private readonly uid;
+    /** Id of the overlay panel, referenced by the host's `aria-controls`. */
+    protected readonly panelId: string;
+    /**
+     * Whether projected content has been resolved. The search field reaches its form control through
+     * its own form field, and that is only guaranteed to have been wired by `ngAfterContentInit`.
+     */
+    private readonly contentInitialized;
+    /**
+     * The last value the form wrote while the tree could not resolve all of it yet — before the content was
+     * initialized, or before the data held every node it names. Applied again as the data changes, until every node
+     * is found or the selection is reported to the form.
+     */
+    private pendingValue;
+    /** The data nodes {@link pendingValue} was last resolved against. */
+    private pendingValueDataNodes;
+    /** Whether the selection is being set to a value the form wrote, which is no change to report back. */
+    private writingValue;
+    /** Handles of the timers that outlive the call that scheduled them. */
+    private readonly pendingTimers;
+    private readonly destroyRef;
+    constructor();
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    updateErrorState(): void;
+    /**
+     * Clears the nodes `clearPredicate` accepts; disabled ones are kept by default.
+     *
+     * Deselects on the model directly: `tree.setOptionsFromValues([])` starts by clearing the whole
+     * model and would take the kept nodes with it.
+     *
+     * @docs-private
+     */
+    clear(): void;
+    /** Reports the selection to the form, which then holds it instead of a value still waiting for its nodes. */
+    private reportValue;
+    /**
+     * Called when the value changes. Needed to properly implement `ControlValueAccessor`.
+     *
+     * @docs-private
+     */
+    onChange: (value: any) => void;
+    /**
+     * Called when the control is blurred. Needed to properly implement `ControlValueAccessor`.
+     *
+     * @docs-private
+     */
+    onTouched: () => void;
+    /** Host click handler. A custom matcher that opts out of the default handlers takes it over. */
+    protected handleClick(): void;
+    toggle(): void;
+    open(): void;
+    private attachPanel;
+    /** Closes the overlay panel and focuses the host element. */
+    close(): void;
+    /**
+     * Reports the panel rendered or removed once the next render has applied `panelOpen`; only the latest
+     * report of a frame is delivered.
+     */
+    private reportPanelRendered;
+    /**
+     * Sets the select's value. Part of the ControlValueAccessor interface
+     * required to integrate with Angular's core forms API.
+     *
+     * @param value New value to be written to the model.
+     */
+    writeValue(value: any): void;
+    /** Applies the value the form wrote last, and lets it go once the data holds every node it names. */
+    private applyPendingValue;
+    /**
+     * Saves a callback function to be invoked when the select's value
+     * changes from user input. Part of the ControlValueAccessor interface
+     * required to integrate with Angular's core forms API.
+     *
+     * @param fn Callback to be triggered when the value changes.
+     */
+    registerOnChange(fn: (value: any) => void): void;
+    /**
+     * Saves a callback function to be invoked when the select is blurred
+     * by the user. Part of the ControlValueAccessor interface required
+     * to integrate with Angular's core forms API.
+     *
+     * @param fn Callback to be triggered when the component has been touched.
+     */
+    registerOnTouched(fn: () => void): void;
+    /**
+     * Disables the select. Part of the ControlValueAccessor interface required
+     * to integrate with Angular's core forms API.
+     *
+     * @param isDisabled Sets whether the component is disabled.
+     */
+    setDisabledState(isDisabled: boolean): void;
+    get selected(): T | T[];
+    get selectedValues(): any;
+    get triggerValue(): string;
+    private readonly emptyValue;
+    /** Whether no node is selected. */
+    readonly empty: _angular_core.Signal<boolean>;
+    /** First selected node that is not disabled — the one the panel highlights when it opens. */
+    protected get firstSelected(): T | undefined;
+    /**
+     * Host keydown handler, routing the event to the trigger or the panel handler. A custom matcher
+     * that opts out of the default handlers reaches those two directly instead.
+     */
+    protected handleKeydown(event: KeyboardEvent): void;
+    onFocus(): void;
+    /**
+     * Calls the touched callback only if the panel is closed. Otherwise, the trigger will
+     * "blur" to the panel when it opens, causing a false positive.
+     */
+    onBlur(): void;
+    /** Callback that is invoked when the overlay panel has been attached. */
+    onAttached(): void;
+    /** Element the overlay is positioned and sized against. */
+    protected getOverlayOriginElement(): HTMLElement | undefined;
+    protected isPanelOpen(): boolean;
+    focus(): void;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    onContainerClick(): void;
+    /** Removes an option from the selection through the trailing icon of its tag in the trigger. */
+    onRemoveSelectedOption(selectedOption: KbqTreeSelectTriggerValue, $event: Event): void;
+    /**
+     * Takes the focus off the remove icon that has just been destroyed along with its tag.
+     *
+     * The trigger is rebuilt synchronously — `selectionModel.changed` runs `refreshTriggerValues()`,
+     * which calls `detectChanges()` — so by the time the click handler returns the icon the keyboard was
+     * on is gone and the focus has fallen back to the document body. Hands it to the icon that took the
+     * removed tag's place, or to the control itself once no removable tag is left.
+     */
+    private restoreFocusAfterRemoval;
+    /**
+     * Recounts the tags of the trigger that do not fit on its first line and refreshes the "+N"
+     * counter. Runs on window resize and whenever the rendered tags change.
+     *
+     * @docs-private
+     */
+    protected calculateHiddenItems: () => void;
+    triggerKeydownHandler(event: KeyboardEvent): void;
+    panelKeydownHandler(event: KeyboardEvent): void;
+    /** @docs-private */
+    protected shouldShowSearch(): boolean;
+    /**
+     * Runs `callback` after the current task, keeping the handle so that destroying the component
+     * cancels it. A timer left to fire after teardown runs against a component that is already gone.
+     */
+    private scheduleTimeout;
+    private closingActions;
+    /**
+     * Measures the tags of the matcher on an off-screen copy of the trigger.
+     *
+     * Two answers are needed — how many tags fit on the first line next to the "+N" counter, and how
+     * wide all of them are together — and they used to cost a clone each. One clone is enough: it is
+     * built, appended and removed once, and the only thing separating the two passes is the counter,
+     * which the second pass drops from the copy.
+     */
+    private measureMatcherItems;
+    private buildTriggerClone;
+    /**
+     * Width of a single `kbq-tag` in the matcher, including margins and the inter-tag gap.
+     *
+     * Tags are `border-box` and carry horizontal padding, which `getComputedStyle().width` — always
+     * the used content-box width — leaves out. See the twin in `KbqSelect`.
+     */
+    private getItemWidth;
+    /** Whether the trigger's tags still agree with the selection about which nodes are disabled. */
+    private hasStaleTriggerValues;
+    private refreshTriggerValues;
+    /**
+     * Sets the selected option based on a value. If no option can be
+     * found with the designated value, the select trigger is cleared.
+     */
+    private setSelectionByValue;
+    private initKeyManager;
+    /**
+     * Sorts the selected nodes by their order in the panel, collapsed branches included, or with `sortComparator`.
+     * A node missing from the data sorts after every node in it.
+     */
+    private sortValues;
+    /** Mirrors the selection into the `value` and `empty` signals. */
+    private syncSelectionState;
+    /**
+     * Highlights the selected item. If no option is selected, it will highlight
+     * the first item instead.
+     */
+    private highlightCorrectOption;
+    private scrollActiveOptionIntoView;
+    /**
+     * Keeps `isEmptySearchResult` in step with the search field.
+     *
+     * The flag is read back once the tree has had the chance to re-render for the new query. Waiting on
+     * the rendered set alone is not enough: a query that filters nothing out leaves the option list —
+     * and therefore its `changes` — silent, and the flag kept answering for the query before it. The
+     * timer is the floor that covers that case.
+     */
+    private subscribeOnSearchChanges;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTreeSelect<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqTreeSelect<any>, "kbq-tree-select", ["kbqTreeSelect"], { "hiddenItemsText": { "alias": "hiddenItemsText"; "required": false; "isSignal": true; }; "hiddenItemsTextFormatter": { "alias": "hiddenItemsTextFormatter"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; "backdropClass": { "alias": "backdropClass"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; "sortComparator": { "alias": "sortComparator"; "required": false; "isSignal": true; }; "clearPredicate": { "alias": "clearPredicate"; "required": false; "isSignal": true; }; "multiline": { "alias": "multiline"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "multipleInput": { "alias": "multiple"; "required": false; "isSignal": true; }; "autoSelectInput": { "alias": "autoSelect"; "required": false; "isSignal": true; }; "selectAllToggle": { "alias": "selectAllToggle"; "required": false; "isSignal": true; }; "selectAll": { "alias": "selectAll"; "required": false; "isSignal": true; }; "idInput": { "alias": "id"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "tabIndexInput": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "selectAllHandlerInput": { "alias": "selectAllHandler"; "required": false; "isSignal": true; }; "panelMinWidth": { "alias": "panelMinWidth"; "required": false; "isSignal": true; }; "panelWidth": { "alias": "panelWidth"; "required": false; "isSignal": true; }; "panelMaxWidth": { "alias": "panelMaxWidth"; "required": false; "isSignal": true; }; "panelMaxHeight": { "alias": "panelMaxHeight"; "required": false; "isSignal": true; }; "searchMinOptionsThresholdInput": { "alias": "searchMinOptionsThreshold"; "required": false; "isSignal": true; }; }, { "openedChangeOutput": "openedChange"; "openedOutput": "opened"; "closedOutput": "closed"; "selectionChange": "selectionChange"; "onSelectAll": "onSelectAll"; }, ["cleaner", "customTrigger", "customMatcher", "customTagTemplateRef", "tree", "search", "noOptionsMessage"], ["kbq-select-matcher, [kbq-select-matcher]", "kbq-select-trigger, [kbq-select-trigger]", "kbq-cleaner", "[kbqSelectSearch]", "[kbq-select-search-empty-result]", "kbq-select-no-options, [kbq-select-no-options]", "kbq-tree-selection", "kbq-select-footer,[kbq-tree-select-footer]"], true, [{ directive: typeof i4.KbqLocaleOverridesDirective; inputs: { "kbqLocaleOverrides": "localeOverrides"; }; outputs: {}; }]>;
+}
+
+/**
+ * The module declares nothing — `KbqTreeSelect` is standalone and brings its own imports — so the
+ * entries below are here either to be re-exported or for the providers they carry (`OverlayModule`,
+ * `KbqTagsModule`, `KbqTreeModule`).
+ */
+declare class KbqTreeSelectModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTreeSelectModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqTreeSelectModule, never, [typeof i1.OverlayModule, typeof i2.KbqTreeModule, typeof i3.KbqTagsModule, typeof i4.KbqSelectSearch, typeof i4.KbqSelectFooter, typeof i4.KbqSelectMatcher, typeof i4.KbqSelectTrigger, typeof i4.KbqSelectSearchEmptyResult, typeof i5.KbqSelectNoOptions, typeof KbqTreeSelect], [typeof KbqTreeSelect, typeof i2.KbqTreeModule, typeof i4.KbqSelectSearch, typeof i4.KbqSelectFooter, typeof i4.KbqSelectMatcher, typeof i4.KbqSelectTrigger, typeof i4.KbqSelectSearchEmptyResult, typeof i5.KbqSelectNoOptions, typeof i7.KbqFormFieldModule]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqTreeSelectModule>;
+}
+
+export { KBQ_TREE_SELECT_OPTIONS, KbqTreeSelect, KbqTreeSelectChange, KbqTreeSelectModule, kbqTreeSelectOptionsProvider };
+export type { KbqTreeSelectOptions, KbqTreeSelectSortComparator, KbqTreeSelectTriggerValue };