@koobiq/components 19.8.3 → 20.1.0

package/filter-bar/index.d.ts

@@ -1 +1,1165 @@
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, ChangeDetectorRef, DestroyRef, ElementRef, TemplateRef, InjectionToken, ModelSignal, Signal, OutputEmitterRef, Type, Provider, OnInit, AfterContentInit } from '@angular/core';
+import * as _koobiq_components_core from '@koobiq/components/core';
+import { PopUpPlacements, KbqComponentColors, PopUpSizes, KbqOption, DateAdapter, DateFormatter, KbqPseudoCheckboxState } from '@koobiq/components/core';
+import { Subject, BehaviorSubject, Observable } from 'rxjs';
+import { FocusMonitor, FocusOrigin } from '@angular/cdk/a11y';
+import { FormControl, FormGroup } from '@angular/forms';
+import { KbqButtonStyles, KbqButton } from '@koobiq/components/button';
+import { KbqDropdownTrigger } from '@koobiq/components/dropdown';
+import { KbqPopoverTrigger } from '@koobiq/components/popover';
+import { KbqSelect } from '@koobiq/components/select';
+import { KbqListSelection } from '@koobiq/components/list';
+import { FlatTreeControl, KbqTreeFlattener, KbqTreeFlatDataSource, KbqTreeSelection, KbqTreeOption } from '@koobiq/components/tree';
+import { KbqTreeSelect } from '@koobiq/components/tree-select';
+
+/** Injection Token for providing configuration of filter-bar */
+declare const KBQ_PIPE_DATA: InjectionToken<unknown>;
+/** function to get unique identifier of an element */
+declare function getId(item: KbqPipeTemplate): KbqPipeType | string | number;
+declare abstract class KbqBasePipe<V> implements AfterViewInit {
+    /** changes of state */
+    readonly stateChanges: Subject<void>;
+    /** pipe data. Provided from subclass */
+    readonly data: KbqPipeData<V>;
+    /** KbqFilterBar instance
+     * @docs-private */
+    protected readonly filterBar: KbqFilterBarHost | null;
+    /** @docs-private */
+    protected readonly changeDetectorRef: ChangeDetectorRef;
+    /** @docs-private */
+    protected readonly destroyRef: DestroyRef;
+    /** @docs-private */
+    protected readonly focusMonitor: FocusMonitor;
+    /** @docs-private */
+    protected readonly elementRef: ElementRef<HTMLElement>;
+    private readonly inputModalityDetector;
+    private readonly document;
+    /** Last known focus origin within the pipe. Used to preserve the keyboard focus ring on restore. */
+    private focusOrigin;
+    /**
+     * Whether this pipe has been destroyed. Guards deferred (`setTimeout`) work that could otherwise
+     * read view queries or mutate `data` after the pipe was removed or the filter switched.
+     * @docs-private
+     */
+    protected destroyed: boolean;
+    /** values to select from the pipe template */
+    protected values: any;
+    /** TemplateRef for selecting an option */
+    protected valueTemplate?: TemplateRef<any> | string;
+    /**
+     * Whether the current platform is a Mac.
+     *
+     * @docs-private
+     */
+    isMac: boolean;
+    /** Data for the pipe.
+     *  @docs-private */
+    $implicit: unknown;
+    /** Whether the current pipe is empty. Used for apply style modifier */
+    get isEmpty(): boolean;
+    /** Whether the current pipe is removable or cleanable. Used for apply style modifier */
+    get showRemoveButton(): boolean;
+    /** localized data
+     * @docs-private */
+    get localeData(): KbqFilterBarConfiguration;
+    constructor();
+    ngAfterViewInit(): void;
+    /** templateRef checker utility */
+    isTemplateRef(value: unknown): boolean;
+    /** updates values for selection and value template */
+    updateTemplates: (templates: KbqPipeTemplate[] | null) => void;
+    /** removes pipe from filter-bar and triggers changes */
+    onRemove(): void;
+    /** clears the pipe and triggers changes */
+    onClear(): void;
+    /**
+     * Restores focus to the pipe's trigger button after a value is chosen or the panel closes.
+     * Focuses via {@link FocusMonitor} with the captured origin so a keyboard-driven interaction
+     * keeps its focus ring, while a mouse-driven one does not.
+     *
+     * @docs-private
+     */
+    protected restoreTriggerFocus(): void;
+    /** @docs-private */
+    abstract open(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqBasePipe<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqBasePipe<any>, never, never, {}, {}, never, never, true, never>;
+}
+declare class KbqPipeMinWidth {
+    /** KbqFilterBar instance */
+    protected readonly filterBar: KbqFilterBarHost | null;
+    /** @docs-private */
+    protected readonly elementRef: ElementRef<HTMLElement>;
+    /** @docs-private */
+    protected readonly changeDetectorRef: ChangeDetectorRef;
+    /** @docs-private */
+    protected minWidth: string;
+    /** maximal symbols for apply fit-content to min-width */
+    maxSymbolsForFitContent: number;
+    /** current length of text */
+    get textLength(): number;
+    constructor();
+    update: () => void;
+    /** Schedules a deferred min-width recompute and returns the effect-cleanup that cancels it. */
+    private scheduleMinWidthUpdate;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeMinWidth, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqPipeMinWidth, "[kbqPipeMinWidth]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Default localized strings for the filter-bar, used when no `KBQ_LOCALE_SERVICE` (nor an explicit
+ * `KBQ_FILTER_BAR_CONFIGURATION`) is provided. These are the Russian (`ru-RU`) strings, matching the
+ * library-wide default-locale convention (every `KBQ_*_DEFAULT_CONFIGURATION` resolves to `ruRULocaleData`).
+ * Provide `KBQ_LOCALE_SERVICE` at the application root to localize the filter-bar for other locales.
+ */
+declare const KBQ_FILTER_BAR_DEFAULT_CONFIGURATION: {
+    reset: {
+        buttonName: string;
+    };
+    search: {
+        tooltip: string;
+        placeholder: string;
+    };
+    filters: {
+        defaultName: string;
+        saveNewFilterTooltip: string;
+        searchPlaceholder: string;
+        searchEmptyResult: string;
+        saveAsNewFilter: string;
+        saveChanges: string;
+        saveAsNew: string;
+        change: string;
+        resetChanges: string;
+        remove: string;
+        name: string;
+        error: string;
+        errorHint: string;
+        saveButton: string;
+        cancelButton: string;
+        actionsTooltip: string;
+    };
+    add: {
+        tooltip: string;
+        addedAnnouncement: string;
+    };
+    refresher: {
+        refresh: string;
+        settings: string;
+    };
+    pipe: {
+        clearButtonTooltip: string;
+        removeButtonTooltip: string;
+        applyButton: string;
+        emptySearchResult: string;
+        selectAll: string;
+    };
+    datePipe: {
+        customPeriod: string;
+        customPeriodFrom: string;
+        customPeriodTo: string;
+        customPeriodErrorHint: string;
+        backToPeriodSelection: string;
+    };
+};
+/** Shape of the localized strings consumed by the filter-bar and its pipes. */
+type KbqFilterBarConfiguration = typeof KBQ_FILTER_BAR_DEFAULT_CONFIGURATION;
+/** Injection Token for providing configuration of filter-bar */
+declare const KBQ_FILTER_BAR_CONFIGURATION: InjectionToken<{
+    reset: {
+        buttonName: string;
+    };
+    search: {
+        tooltip: string;
+        placeholder: string;
+    };
+    filters: {
+        defaultName: string;
+        saveNewFilterTooltip: string;
+        searchPlaceholder: string;
+        searchEmptyResult: string;
+        saveAsNewFilter: string;
+        saveChanges: string;
+        saveAsNew: string;
+        change: string;
+        resetChanges: string;
+        remove: string;
+        name: string;
+        error: string;
+        errorHint: string;
+        saveButton: string;
+        cancelButton: string;
+        actionsTooltip: string;
+    };
+    add: {
+        tooltip: string;
+        addedAnnouncement: string;
+    };
+    refresher: {
+        refresh: string;
+        settings: string;
+    };
+    pipe: {
+        clearButtonTooltip: string;
+        removeButtonTooltip: string;
+        applyButton: string;
+        emptySearchResult: string;
+        selectAll: string;
+    };
+    datePipe: {
+        customPeriod: string;
+        customPeriodFrom: string;
+        customPeriodTo: string;
+        customPeriodErrorHint: string;
+        backToPeriodSelection: string;
+    };
+}>;
+/**
+ * Contract a pipe (or filter-bar sub-component) depends on instead of the concrete `KbqFilterBar`.
+ * `KbqFilterBar` provides itself as {@link KBQ_FILTER_BAR_HOST}, so a pipe can be unit-tested against a
+ * lightweight mock of this seam rather than a full bar. Members mirror the current `KbqFilterBar` surface;
+ * they are expected to slim down once the state model moves to signals.
+ */
+interface KbqFilterBarHost {
+    /** Localized strings and configuration for the filter-bar and its pipes. */
+    configuration: KbqFilterBarConfiguration;
+    /** Currently selected filter. A two-way-bindable `model()`: read via `filter()`, write via `filter.set()`. */
+    readonly filter: ModelSignal<KbqFilter | null>;
+    /** Templates used when adding a pipe (also hold the option lists). Read via `pipeTemplates()`. */
+    readonly pipeTemplates: Signal<KbqPipeTemplate[]>;
+    /** Whether selecting all options counts as selecting nothing. */
+    readonly selectedAllEqualsSelectedNothing: Signal<boolean>;
+    /** Whether the current filter is saved. */
+    readonly isSaved: Signal<boolean>;
+    /** Whether the current filter is changed. */
+    readonly isChanged: Signal<boolean>;
+    /** Whether the current filter is both saved and changed. */
+    readonly isSavedAndChanged: Signal<boolean>;
+    /** Whether the current filter is readonly. */
+    readonly isReadOnly: Signal<boolean>;
+    /**
+     * Emits whenever a pipe value changes.
+     * (The two-way-bound `filter` value is emitted by the `filter` model's `filterChange` output.)
+     */
+    readonly onChangePipe: OutputEmitterRef<KbqPipe>;
+    /** Emits whenever a pipe is cleared. */
+    readonly onClearPipe: OutputEmitterRef<KbqPipe>;
+    /** Emits whenever a select/multiselect pipe closes. */
+    readonly onClosePipe: OutputEmitterRef<KbqPipe>;
+    /** Internal filter changes. */
+    readonly internalFilterChanges: BehaviorSubject<KbqFilter | null>;
+    /** Internal pipe-template changes. */
+    readonly internalTemplatesChanges: BehaviorSubject<KbqPipeTemplate[] | null>;
+    /** Requests opening a pipe after it is added. */
+    readonly openPipe: BehaviorSubject<string | number | null>;
+    /** Emits when the filter is reset. */
+    readonly onResetFilter: BehaviorSubject<boolean>;
+    /** Removes a pipe from the current filter and emits the change. */
+    removePipe(pipe: KbqPipe): void;
+    /** Clears the current filter's "changed" flag. */
+    resetFilterChangedState(): void;
+}
+/**
+ * Injection token exposing the {@link KbqFilterBarHost} seam. `KbqFilterBar` provides itself via
+ * `useExisting`, so pipes `inject(KBQ_FILTER_BAR_HOST)` instead of depending on the concrete bar.
+ */
+declare const KBQ_FILTER_BAR_HOST: InjectionToken<KbqFilterBarHost>;
+/** Injection Token for providing pipes in filter-bar */
+declare const KBQ_FILTER_BAR_PIPES: InjectionToken<Map<KbqPipeType, Type<KbqBasePipe<unknown>>>>;
+/** Utility provider for `KBQ_FILTER_BAR_PIPES`. */
+declare const kbqFilterBarPipesProvider: () => Provider;
+/** list of pipe types available out of the box */
+declare enum KbqPipeTypes {
+    ReadOnly = "readonly",
+    Text = "text",
+    Select = "select",
+    TreeSelect = "tree-select",
+    MultiSelect = "multiselect",
+    MultiTreeSelect = "multi-tree-select",
+    Date = "date",
+    Datetime = "datetime"
+}
+type KbqPipeType = `${KbqPipeTypes}` | (string & {});
+/** list of pipes available out of the box. */
+declare const defaultFilterBarPipes: [KbqPipeType, Type<KbqBasePipe<unknown>>][];
+interface KbqDateTimeValue {
+    name?: string;
+    start?: string;
+    end?: string;
+}
+interface KbqSelectValue {
+    name: string;
+    value: unknown;
+    /** Optional stable identifier used by the select/multi-select pipe comparators. */
+    id?: string | number;
+}
+interface KbqFilter {
+    name: string;
+    pipes: KbqPipe[];
+    readonly: boolean;
+    disabled: boolean;
+    changed: boolean;
+    saved: boolean;
+}
+interface KbqPipe {
+    name: string;
+    id?: string | number;
+    type: KbqPipeType;
+    value: unknown | null;
+    search?: boolean;
+    selectAll?: boolean;
+    openOnAdd?: boolean;
+    openOnReset?: boolean;
+    /**
+     * This is special logic that unselect all items when all selected because "all selected = nothing selected".
+     * Default is true
+     * */
+    selectedAllEqualsSelectedNothing?: boolean;
+    /** @deprecated use cleanable = false and removable = false instead */
+    required?: boolean;
+    cleanable: boolean;
+    removable: boolean;
+    disabled: boolean;
+}
+interface KbqPipeData<V> extends KbqPipe {
+    value: V | null;
+}
+interface KbqPipeTemplate extends Omit<KbqPipe, 'value'> {
+    values?: unknown[];
+    valueTemplate?: TemplateRef<any> | string;
+}
+interface KbqSaveFilterError {
+    text?: string;
+    nameAlreadyExists?: boolean;
+}
+/** saving statuses for KbqSaveFilterEvent */
+declare enum KbqSaveFilterStatuses {
+    OnlyChanges = "onlyChanges",
+    NewName = "newName",
+    NewFilter = "newFilter"
+}
+interface KbqSaveFilterEvent {
+    filter: KbqFilter;
+    filterBar: KbqFilterBar;
+    status?: KbqSaveFilterStatuses;
+}
+/** Flattened node */
+declare class KbqTreeSelectFlatNode {
+    name: string;
+    value: unknown;
+    level: number;
+    expandable: boolean;
+    parent?: KbqTreeSelectFlatNode;
+}
+interface KbqTreeSelectNode {
+    children: KbqTreeSelectNode[] | null;
+    name: string;
+    value: unknown;
+}
+/**
+ * Build the file structure tree. The `value` is the Json object, or a sub-tree of a Json object.
+ * The return value is the list of extends `KbqTreeSelectNode`.
+ */
+declare function kbqBuildTree<T extends KbqTreeSelectNode>(value: Record<string, unknown>, level: number): T[];
+
+declare class KbqFilterReset {
+    /** KbqFilterBar host seam */
+    private readonly filterBar;
+    /** Event that is generated whenever the user reset a filter. */
+    readonly onResetFilter: _angular_core.OutputEmitterRef<KbqFilter | null>;
+    /** localized data
+     * @docs-private */
+    get localeData(): string;
+    protected resetFilter(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqFilterReset, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqFilterReset, "kbq-filter-reset", never, {}, { "onResetFilter": "onResetFilter"; }, never, ["*"], true, never>;
+}
+
+/**
+ * The "save / rename filter" popover, extracted from `KbqFilters` (SRP). Owns the save form state, the
+ * name control, validation/error display and the save/rename flow. It declares the popover's header,
+ * content and footer templates and pushes them imperatively onto the trigger it is given (via the
+ * `popoverTrigger` input), so there is no cross-component template binding on the parent (which would
+ * otherwise risk `ExpressionChangedAfterItHasBeenCheckedError`). `KbqFilters` keeps the trigger (on its
+ * main button), focus management and the public `filterSavedSuccessfully`/`filterSavedUnsuccessfully` API,
+ * delegating to this component.
+ *
+ * @docs-private
+ */
+declare class KbqFilterSavePopover implements AfterViewInit {
+    private readonly changeDetectorRef;
+    /** Popover trigger owned by the parent (`KbqFilters` main button). */
+    readonly popoverTrigger: _angular_core.InputSignal<KbqPopoverTrigger>;
+    /** Filter bar, used for the save payload, the current filter and localized strings. */
+    readonly filterBar: _angular_core.InputSignal<KbqFilterBar>;
+    /** Emits when the user saves/renames a filter. */
+    readonly save: _angular_core.OutputEmitterRef<KbqSaveFilterEvent>;
+    /** Emits when the popover closes; the boolean requests focus restoration by the parent. */
+    readonly closed: _angular_core.OutputEmitterRef<boolean>;
+    /** @docs-private */
+    readonly headerTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    /** @docs-private */
+    readonly contentTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    /** @docs-private */
+    readonly footerTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    private readonly newFilterName;
+    private readonly saveFilterButton;
+    /** new filter name for saving */
+    filterName: FormControl<string | null>;
+    /** true if saving a new filter, false if saving changes in filter */
+    saveNewFilter: boolean;
+    showFilterSavingError: boolean;
+    filterSavingErrorText: string;
+    isSaving: boolean;
+    /** localized data
+     * @docs-private */
+    get localeData(): {
+        defaultName: string;
+        saveNewFilterTooltip: string;
+        searchPlaceholder: string;
+        searchEmptyResult: string;
+        saveAsNewFilter: string;
+        saveChanges: string;
+        saveAsNew: string;
+        change: string;
+        resetChanges: string;
+        remove: string;
+        name: string;
+        error: string;
+        errorHint: string;
+        saveButton: string;
+        cancelButton: string;
+        actionsTooltip: string;
+    };
+    /** header of popover. Depends on the mode */
+    get popoverHeader(): string;
+    ngAfterViewInit(): void;
+    openSaveAsNewFilterPopover(): void;
+    openChangeFilterNamePopover(): void;
+    saveAsNew(event?: Event): void;
+    showError(error?: KbqSaveFilterError): void;
+    close: (restoreFocus?: boolean) => void;
+    /** Hide the popover on a successful save. Focus restoration is handled by the parent. */
+    savedSuccessfully(): void;
+    /** Release the saving state after a failed save (the error itself is shown by the host via `showError`). */
+    savedUnsuccessfully(): void;
+    private preparePopover;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqFilterSavePopover, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqFilterSavePopover, "kbq-filter-save-popover", never, { "popoverTrigger": { "alias": "popoverTrigger"; "required": true; "isSignal": true; }; "filterBar": { "alias": "filterBar"; "required": true; "isSignal": true; }; }, { "save": "save"; "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class KbqFilters implements OnInit {
+    /** @docs-private */
+    protected readonly elementRef: ElementRef<any>;
+    /** @docs-private */
+    protected readonly destroyRef: DestroyRef;
+    /** @docs-private */
+    protected readonly focusMonitor: FocusMonitor;
+    /** @docs-private */
+    protected readonly placements: typeof PopUpPlacements;
+    /** @docs-private */
+    protected readonly styles: typeof KbqButtonStyles;
+    /** @docs-private */
+    protected readonly colors: typeof KbqComponentColors;
+    /** KbqFilterBar instance */
+    protected readonly filterBar: KbqFilterBar;
+    /** @docs-private */
+    private readonly changeDetectorRef;
+    /** @docs-private */
+    protected readonly mainButton: _angular_core.Signal<KbqButton>;
+    /** @docs-private */
+    protected readonly saveNewFilterButton: _angular_core.Signal<KbqButton>;
+    /** @docs-private */
+    protected readonly filterActionsButton: _angular_core.Signal<KbqButton>;
+    /** @docs-private */
+    protected readonly popover: _angular_core.Signal<KbqPopoverTrigger>;
+    /** @docs-private */
+    protected readonly dropdown: _angular_core.Signal<KbqDropdownTrigger>;
+    /** @docs-private */
+    protected readonly filterActionsDropdown: _angular_core.Signal<KbqDropdownTrigger | undefined>;
+    /** @docs-private */
+    protected readonly savePopover: _angular_core.Signal<KbqFilterSavePopover>;
+    private readonly search;
+    /** control for search filter */
+    readonly searchControl: FormControl<string | null>;
+    /** filtered by search filters */
+    filteredOptions: Observable<KbqFilter[]>;
+    /** @docs-private */
+    protected readonly popoverSize = PopUpSizes.Medium;
+    /** @docs-private */
+    protected readonly popoverOffset: number;
+    readonly filters: _angular_core.InputSignal<KbqFilter[]>;
+    /** Event that is generated whenever the user selects a filter. */
+    readonly onSelectFilter: _angular_core.OutputEmitterRef<KbqFilter>;
+    /**
+     * Event that is generated whenever the user save a filter.
+     *
+     * The emitted `filter` shares its pipe objects with the live filter by design (so the rendered pipes keep
+     * their identity across a save instead of being destroyed and recreated). Consumers that persist
+     * `event.filter` as an immutable record should snapshot it first (e.g. via `KbqFilterBar.saveFilterState`
+     * or a structural copy) — otherwise later in-place pipe edits will mutate the stored reference.
+     */
+    readonly onSave: _angular_core.OutputEmitterRef<KbqSaveFilterEvent>;
+    /** Event that is generated whenever the user change a filter. */
+    readonly onChangeFilter: _angular_core.OutputEmitterRef<KbqSaveFilterEvent>;
+    /** Event that is generated whenever the user remove a filter. */
+    readonly onRemoveFilter: _angular_core.OutputEmitterRef<KbqFilter>;
+    /** Event that is generated whenever the user reset a filter changes. */
+    readonly onResetFilterChanges: _angular_core.OutputEmitterRef<KbqFilter | null>;
+    /** Component state. true if opened dropdown or popup */
+    get opened(): boolean;
+    /** Component state. true if opened dropdown or popup of filterActions */
+    get filterActionsOpened(): boolean;
+    /** Selected filter. Kept as a plain getter facade over the bar's `filter` model. */
+    get filter(): KbqFilter | null;
+    /** Component state. True if 'filters' input contains no elements. */
+    get isEmpty(): boolean;
+    /** localized data
+     * @docs-private */
+    get localeData(): {
+        defaultName: string;
+        saveNewFilterTooltip: string;
+        searchPlaceholder: string;
+        searchEmptyResult: string;
+        saveAsNewFilter: string;
+        saveChanges: string;
+        saveAsNew: string;
+        change: string;
+        resetChanges: string;
+        remove: string;
+        name: string;
+        error: string;
+        errorHint: string;
+        saveButton: string;
+        cancelButton: string;
+        actionsTooltip: string;
+    };
+    /** Current focus origin state.
+     * @docs-private */
+    get focusOrigin(): FocusOrigin;
+    private _focusOrigin;
+    private focusedElementBeforeOpen;
+    ngOnInit(): void;
+    /** @docs-private */
+    focusedElementBeforeIs(button: KbqButton): boolean;
+    selectFilter(filter: KbqFilter): void;
+    saveChanges(): void;
+    restoreFocus(): void;
+    /** @docs-private */
+    saveFocusedElement(button?: KbqButton): void;
+    /** Restore focus when the save popover reports it closed. @docs-private */
+    onSavePopoverClosed(restoreFocus: boolean): void;
+    /** @docs-private */
+    stopEventPropagation(event: Event): void;
+    /** @docs-private */
+    searchKeydownHandler(event: KeyboardEvent): void;
+    /** @docs-private */
+    onDropdownOpen(): void;
+    resetFilterChanges(): void;
+    removeFilter(): void;
+    /** Hide the popup and restore focus.
+     * Use this method in the onSave or onChangeFilter events after the data has been successfully saved. */
+    filterSavedSuccessfully(): void;
+    /** Shows an error. Use this method in the onSave or onChangeFilter events if saving data failed. */
+    filterSavedUnsuccessfully(error?: KbqSaveFilterError): void;
+    /** @docs-private */
+    get filterName(): FormControl<string | null>;
+    /** @docs-private */
+    get saveNewFilter(): boolean;
+    /** @docs-private */
+    set saveNewFilter(value: boolean);
+    /** @docs-private */
+    get isSaving(): boolean;
+    /** @docs-private */
+    set isSaving(value: boolean);
+    /** @docs-private */
+    get showFilterSavingError(): boolean;
+    /** @docs-private */
+    set showFilterSavingError(value: boolean);
+    /** @docs-private */
+    get filterSavingErrorText(): string;
+    /** header of popover. Depends on the mode
+     * @docs-private */
+    get popoverHeader(): string;
+    /** @docs-private */
+    openSaveAsNewFilterPopover(): void;
+    /** @docs-private */
+    openChangeFilterNamePopover(): void;
+    /** @docs-private */
+    saveAsNew(event?: Event): void;
+    /** @docs-private */
+    showError(error?: KbqSaveFilterError): void;
+    /** @docs-private */
+    closePopover(restoreFocus?: boolean): void;
+    private getFilteredOptions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqFilters, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqFilters, "kbq-filters", ["kbqFilters"], { "filters": { "alias": "filters"; "required": true; "isSignal": true; }; }, { "onSelectFilter": "onSelectFilter"; "onSave": "onSave"; "onChangeFilter": "onChangeFilter"; "onRemoveFilter": "onRemoveFilter"; "onResetFilterChanges": "onResetFilterChanges"; }, never, ["*"], true, never>;
+}
+
+declare class KbqFilterBar implements KbqFilterBarHost {
+    /** @docs-private */
+    protected readonly changeDetectorRef: ChangeDetectorRef;
+    /** @docs-private */
+    protected readonly localeService: _koobiq_components_core.KbqLocaleService | null;
+    readonly externalConfiguration: {
+        reset: {
+            buttonName: string;
+        };
+        search: {
+            tooltip: string;
+            placeholder: string;
+        };
+        filters: {
+            defaultName: string;
+            saveNewFilterTooltip: string;
+            searchPlaceholder: string;
+            searchEmptyResult: string;
+            saveAsNewFilter: string;
+            saveChanges: string;
+            saveAsNew: string;
+            change: string;
+            resetChanges: string;
+            remove: string;
+            name: string;
+            error: string;
+            errorHint: string;
+            saveButton: string;
+            cancelButton: string;
+            actionsTooltip: string;
+        };
+        add: {
+            tooltip: string;
+            addedAnnouncement: string;
+        };
+        refresher: {
+            refresh: string;
+            settings: string;
+        };
+        pipe: {
+            clearButtonTooltip: string;
+            removeButtonTooltip: string;
+            applyButton: string;
+            emptySearchResult: string;
+            selectAll: string;
+        };
+        datePipe: {
+            customPeriod: string;
+            customPeriodFrom: string;
+            customPeriodTo: string;
+            customPeriodErrorHint: string;
+            backToPeriodSelection: string;
+        };
+    } | null;
+    /** Localized strings and configuration for the filter-bar and its pipes. */
+    configuration: KbqFilterBarConfiguration;
+    /** @docs-private */
+    readonly filters: _angular_core.Signal<KbqFilters | undefined>;
+    /** @docs-private */
+    readonly filterReset: _angular_core.Signal<KbqFilterReset | undefined>;
+    /**
+     * This is special logic that unselect all items when all selected because "all selected = nothing selected".
+     * Default is true
+     * */
+    readonly selectedAllEqualsSelectedNothing: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Filter that is currently selected. A two-way-bindable `model()`: derived state (`isSaved`/`isChanged`/…)
+     * is exposed via `computed()` off it and change detection is driven by signal reactivity. `model()`
+     * auto-provides the `filterChange` output for `[(filter)]` two-way binding.
+     */
+    readonly filter: _angular_core.ModelSignal<KbqFilter | null>;
+    /** An array of templates that are used when adding a pipe. Also contains lists of options to select (values). */
+    readonly pipeTemplates: _angular_core.InputSignal<KbqPipeTemplate[]>;
+    /** Event that emits whenever the value of the pipe changes. */
+    readonly onChangePipe: _angular_core.OutputEmitterRef<KbqPipe>;
+    /** Event that emits whenever the pipe deleted. */
+    readonly onRemovePipe: _angular_core.OutputEmitterRef<KbqPipe>;
+    /** Event that emits whenever the pipe cleared. */
+    readonly onClearPipe: _angular_core.OutputEmitterRef<KbqPipe>;
+    /** Event that emits whenever the select or multiselect pipe closed. */
+    readonly onClosePipe: _angular_core.OutputEmitterRef<KbqPipe>;
+    /** Whether the current filter is saved */
+    readonly isSaved: _angular_core.Signal<boolean>;
+    /** Whether the current filter is changed */
+    readonly isChanged: _angular_core.Signal<boolean>;
+    /** Whether the current filter is saved and changed */
+    readonly isSavedAndChanged: _angular_core.Signal<boolean>;
+    /** Whether the current filter is readonly */
+    readonly isReadOnly: _angular_core.Signal<boolean>;
+    /** Whether the current filter is disabled */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    private savedFilter;
+    /**
+     * All changes.
+     * @deprecated noop. Reactivity is driven by the `filter` signal now; this never emits and will be
+     * removed in the next major.
+     */
+    readonly changes: BehaviorSubject<void>;
+    /** Event that emits whenever the filter is reset. */
+    readonly onResetFilter: BehaviorSubject<boolean>;
+    /** internal filter changes */
+    readonly internalFilterChanges: BehaviorSubject<KbqFilter | null>;
+    /** internal changes in templates */
+    readonly internalTemplatesChanges: BehaviorSubject<KbqPipeTemplate[] | null>;
+    /** this subject need for opens pipe after adding
+     * @docs-private */
+    readonly openPipe: BehaviorSubject<string | number | null>;
+    constructor();
+    /** Remove pipe from current filter and emit event */
+    removePipe(pipe: KbqPipe): void;
+    /**
+     * Save current state of filter.
+     *
+     * Deep-clones the filter via `structuredClone`, so any pipe `value` payload handed to save/restore must be
+     * structured-cloneable (plain data — no functions, DOM nodes, class instances or `TemplateRef`s), otherwise
+     * `structuredClone` throws `DataCloneError`. All built-in pipes produce cloneable values.
+     */
+    saveFilterState(filter?: KbqFilter): void;
+    /**
+     * Restore previously saved filter state.
+     *
+     * @see `saveFilterState` — pipe `value` payloads must be structured-cloneable.
+     */
+    restoreFilterState(filter?: KbqFilter): void;
+    /** Set the filter state "changed" to false */
+    resetFilterChangedState(): void;
+    private updateLocaleParams;
+    private initDefaultParams;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqFilterBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqFilterBar, "kbq-filter-bar, [kbq-filter-bar]", never, { "selectedAllEqualsSelectedNothing": { "alias": "selectedAllEqualsSelectedNothing"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "pipeTemplates": { "alias": "pipeTemplates"; "required": false; "isSignal": true; }; }, { "filter": "filterChange"; "onChangePipe": "onChangePipe"; "onRemovePipe": "onRemovePipe"; "onClearPipe": "onClearPipe"; "onClosePipe": "onClosePipe"; }, ["filters", "filterReset"], ["kbq-filters", "*", "kbq-pipe-add", "kbq-filter-reset", "kbq-search-expandable", "kbq-filter-refresher, [kbq-filter-refresher]"], true, never>;
+}
+
+declare class KbqFilterBarButton {
+    private readonly button;
+    /** KbqFilterBar host seam */
+    private readonly filterBar;
+    /** KbqFilters instance */
+    protected readonly filters: KbqFilters;
+    constructor();
+    /** @docs-private */
+    saveFocusedElement(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqFilterBarButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqFilterBarButton, "[kbqFilterBarButton]", never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqFilterRefresher {
+    /** KbqFilterBar host seam */
+    private readonly filterBar;
+    /** localized data
+     * @docs-private */
+    protected get localeData(): {
+        reset: {
+            buttonName: string;
+        };
+        search: {
+            tooltip: string;
+            placeholder: string;
+        };
+        filters: {
+            defaultName: string;
+            saveNewFilterTooltip: string;
+            searchPlaceholder: string;
+            searchEmptyResult: string;
+            saveAsNewFilter: string;
+            saveChanges: string;
+            saveAsNew: string;
+            change: string;
+            resetChanges: string;
+            remove: string;
+            name: string;
+            error: string;
+            errorHint: string;
+            saveButton: string;
+            cancelButton: string;
+            actionsTooltip: string;
+        };
+        add: {
+            tooltip: string;
+            addedAnnouncement: string;
+        };
+        refresher: {
+            refresh: string;
+            settings: string;
+        };
+        pipe: {
+            clearButtonTooltip: string;
+            removeButtonTooltip: string;
+            applyButton: string;
+            emptySearchResult: string;
+            selectAll: string;
+        };
+        datePipe: {
+            customPeriod: string;
+            customPeriodFrom: string;
+            customPeriodTo: string;
+            customPeriodErrorHint: string;
+            backToPeriodSelection: string;
+        };
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqFilterRefresher, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqFilterRefresher, "kbq-filter-refresher, [kbq-filter-refresher]", never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqPipeAdd {
+    /** KbqFilterBar instance */
+    protected readonly filterBar: KbqFilterBarHost;
+    /** @docs-private */
+    readonly select: _angular_core.Signal<KbqSelect>;
+    /** Event that is generated after add pipe. */
+    readonly onAddPipe: _angular_core.OutputEmitterRef<KbqPipeTemplate>;
+    /** template of filter */
+    readonly filterTemplate: _angular_core.InputSignal<KbqFilter>;
+    /**
+     * Ids of the pipes already added to the current filter. Used to open an already-added pipe.
+     * Derived from the `filter` signal so it stays in sync without the retired `changes` bus.
+     */
+    readonly addedPipes: _angular_core.Signal<(string | number | (string & {}))[]>;
+    /**
+     * Visually-hidden live-region text announcing a newly-added pipe to assistive tech (WCAG 4.1.3).
+     * @docs-private
+     */
+    protected readonly announcement: _angular_core.WritableSignal<string>;
+    addPipeFromTemplate(option: KbqOption): void;
+    /**
+     * Function to compare the option values with the selected values. The first argument
+     * is a value from an option. The second is a value from the selection. A boolean
+     * should be returned.
+     */
+    compareWith(o1: KbqPipe, o2: string): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeAdd, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPipeAdd, "kbq-pipe-add", never, { "filterTemplate": { "alias": "filterTemplate"; "required": false; "isSignal": true; }; }, { "onAddPipe": "onAddPipe"; }, never, never, true, never>;
+}
+
+declare class KbqPipeDirective<T extends KbqPipe> implements AfterContentInit {
+    private injector;
+    private pipes;
+    private viewContainerRef;
+    readonly pipe: _angular_core.InputSignal<T>;
+    ngAfterContentInit(): void;
+    private getInjector;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqPipeDirective<any>, "[kbqPipe]", never, { "pipe": { "alias": "kbqPipe"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class KbqPipeButton {
+    /** KbqPipe instance */
+    protected readonly pipe: KbqBasePipe<any>;
+    /** KbqFilterBar instance */
+    protected readonly filterBar: KbqFilterBarHost;
+    /** @docs-private */
+    protected readonly changeDetectorRef: ChangeDetectorRef;
+    /** enables/disables read-only state */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** localized data
+     * @docs-private */
+    get localeData(): {
+        clearButtonTooltip: string;
+        removeButtonTooltip: string;
+        applyButton: string;
+        emptySearchResult: string;
+        selectAll: string;
+    };
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPipeButton, "kbq-pipe-button", never, { "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class KbqPipeState<T> {
+    /** @docs-private */
+    private readonly button;
+    /** @docs-private */
+    private readonly pipe;
+    /** KbqFilterBar instance
+     * @docs-private */
+    private readonly filterBar;
+    /** Pipe state used to calculate/update the button style. */
+    readonly state: _angular_core.InputSignal<T | null>;
+    constructor();
+    private updateState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeState<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqPipeState<any>, "[kbqPipeState]", never, { "state": { "alias": "kbqPipeState"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class KbqFilterBarModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqFilterBarModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqFilterBarModule, never, [typeof KbqFilterBar, typeof KbqFilters, typeof KbqFilterRefresher, typeof KbqFilterBarButton, typeof KbqFilterReset, typeof KbqPipeAdd, typeof KbqPipeDirective, typeof KbqPipeButton, typeof KbqPipeState], [typeof KbqFilterBar, typeof KbqFilters, typeof KbqFilterRefresher, typeof KbqFilterBarButton, typeof KbqFilterReset, typeof KbqPipeAdd, typeof KbqPipeDirective, typeof KbqPipeButton, typeof KbqPipeState]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqFilterBarModule>;
+}
+
+/**
+ * Shared implementation for the `date` and `datetime` pipes. The two pipes differ only in how a range
+ * is formatted and in their default start/end values, exposed here as the {@link formatRange},
+ * {@link getDefaultStart} and {@link getDefaultEnd} hooks. Everything else — the period list / custom
+ * period flow, calendar handling and form group — is common.
+ */
+declare abstract class KbqPipeDateBaseComponent<D> extends KbqBasePipe<KbqDateTimeValue> implements AfterViewInit {
+    protected readonly adapter: DateAdapter<any>;
+    protected readonly formatter: DateFormatter<any>;
+    /** @docs-private */
+    protected readonly placements: typeof PopUpPlacements;
+    /** @docs-private */
+    protected readonly styles: typeof KbqButtonStyles;
+    /** @docs-private */
+    protected readonly colors: typeof KbqComponentColors;
+    /** Whether the current state is list of periods. When false will displayed control for set custom period */
+    protected isListMode: boolean;
+    /** @docs-private */
+    protected formGroup: FormGroup;
+    /** @docs-private */
+    protected showStartCalendar: boolean;
+    /** @docs-private */
+    protected showEndCalendar: boolean;
+    /** @docs-private */
+    readonly popover: _angular_core.Signal<KbqPopoverTrigger>;
+    /** @docs-private */
+    readonly listSelection: _angular_core.Signal<KbqListSelection | undefined>;
+    /** @docs-private */
+    readonly returnButton: _angular_core.Signal<KbqButton>;
+    /** formatted value for period */
+    get formattedValue(): string;
+    /** Whether the current pipe is disabled. */
+    get disabled(): boolean;
+    /** parsed start */
+    get start(): D;
+    /** default object for start */
+    get defaultStart(): D;
+    /** parsed end */
+    get end(): D;
+    /** default object for end */
+    get defaultEnd(): D;
+    /** Whether the current pipe is empty. */
+    get isEmpty(): boolean;
+    ngAfterViewInit(): void;
+    /** keydown handler
+     * @docs-private */
+    onKeydown($event: KeyboardEvent): void;
+    onApplyPeriod(): void;
+    onSelect(item: KbqDateTimeValue): void;
+    showPeriod(): void;
+    showList(): void;
+    /** opens popover */
+    open(): void;
+    onSelectStartDate(value: D): void;
+    onSelectEndDate(value: D): void;
+    onFocusStartInput(): void;
+    onFocusEndInput(): void;
+    hideCalendars(): void;
+    /** Formats the selected range for display. */
+    protected abstract formatRange(start: D, end: D): string;
+    /** Default start value used when the pipe has no stored `start`. */
+    protected abstract getDefaultStart(): D;
+    /** Default end value used when the pipe has no stored `start`. */
+    protected abstract getDefaultEnd(): D;
+    private initFormGroup;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeDateBaseComponent<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqPipeDateBaseComponent<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqPipeDateComponent<D> extends KbqPipeDateBaseComponent<D> {
+    protected formatRange(start: D, end: D): string;
+    protected getDefaultStart(): D;
+    protected getDefaultEnd(): D;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeDateComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPipeDateComponent<any>, "kbq-pipe-date", never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqPipeDatetimeComponent<D> extends KbqPipeDateBaseComponent<D> {
+    protected formatRange(start: D, end: D): string;
+    protected getDefaultStart(): D;
+    protected getDefaultEnd(): D;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeDatetimeComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPipeDatetimeComponent<any>, "kbq-pipe-datetime", never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqPipeMultiSelectComponent extends KbqBasePipe<KbqSelectValue[]> implements AfterViewInit, OnInit {
+    /** control for search options */
+    readonly searchControl: FormControl<string | null>;
+    /** filtered by search options */
+    filteredOptions: Observable<KbqSelectValue[]>;
+    /** @docs-private */
+    readonly select: _angular_core.Signal<KbqSelect>;
+    /** @docs-private */
+    readonly options: _angular_core.Signal<readonly KbqOption[]>;
+    /** selected value */
+    get selected(): KbqSelectValue[] | null;
+    /** Whether the current pipe is empty. */
+    get isEmpty(): boolean;
+    /** state for checkbox 'select all'. */
+    get checkboxState(): KbqPseudoCheckboxState;
+    /** true if all visible options selected */
+    get allVisibleOptionsSelected(): boolean;
+    /** true if all options selected */
+    get allOptionsSelected(): boolean;
+    get selectedAllEqualsSelectedNothing(): boolean;
+    private get visibleOptions();
+    private selectionAllInProgress;
+    private readonly multiSelect;
+    /** @docs-private */
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    /** @docs-private */
+    onSelect(item: KbqSelectValue[]): void;
+    /** @docs-private */
+    onClear(): void;
+    /** @docs-private */
+    toggleSelectionAllByEnterKey(): void;
+    /** @docs-private */
+    toggleSelectionAll(emitEvent?: boolean): void;
+    /** Comparator of selected options. Two null/absent values never match (aligned with the select pipe). */
+    compareByValue: (o1: Pick<KbqSelectValue, "id"> | null, o2: Pick<KbqSelectValue, "id"> | null) => boolean;
+    /** handler for select all options in select */
+    selectAllHandler: (event: KeyboardEvent) => void;
+    /** @docs-private */
+    onClose(): void;
+    /** opens select */
+    open(): void;
+    private getFilteredOptions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeMultiSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPipeMultiSelectComponent, "kbq-pipe-multi-select", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Shared scaffolding for the tree-based select pipes (`kbq-pipe-tree-select`,
+ * `kbq-pipe-multi-tree-select`): the flat-tree control / flattener / data source, the node accessors,
+ * search-driven filtering and open handling. Subclasses provide the value-specific pieces (`selected`,
+ * `isEmpty`, `onSelect`, `updateTemplates`).
+ *
+ * The `internalTemplatesChanges` subscription is intentionally left in each subclass constructor: it must
+ * be set up after the subclass's `updateTemplates` field initializer runs, so the initial `BehaviorSubject`
+ * replay dispatches to the subclass override (which writes `dataSource.data`) rather than the base one.
+ */
+declare abstract class KbqTreeSelectPipeBase<V> extends KbqBasePipe<V> implements OnInit, AfterViewInit {
+    /** control for search options */
+    readonly searchControl: FormControl<string | null>;
+    treeControl: FlatTreeControl<KbqTreeSelectFlatNode>;
+    treeFlattener: KbqTreeFlattener<KbqTreeSelectNode, KbqTreeSelectFlatNode>;
+    dataSource: KbqTreeFlatDataSource<KbqTreeSelectNode, KbqTreeSelectFlatNode>;
+    /** @docs-private */
+    readonly select: _angular_core.Signal<KbqTreeSelect>;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    /** tree-node predicate: whether the node has children */
+    hasChild(_: number, nodeData: KbqTreeSelectFlatNode): boolean;
+    /** opens the tree-select panel */
+    open(): void;
+    /** @docs-private */
+    onOpen(): void;
+    protected transformer: (node: KbqTreeSelectNode, level: number, parent: KbqTreeSelectFlatNode | null) => KbqTreeSelectFlatNode;
+    protected getLevel: (node: KbqTreeSelectFlatNode) => number;
+    protected isExpandable: (node: KbqTreeSelectFlatNode) => boolean;
+    protected getChildren: (node: KbqTreeSelectNode) => KbqTreeSelectNode[] | null;
+    protected getValue: (node: KbqTreeSelectFlatNode) => unknown;
+    protected getViewValue: (node: KbqTreeSelectFlatNode) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTreeSelectPipeBase<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTreeSelectPipeBase<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqPipeMultiTreeSelectComponent extends KbqTreeSelectPipeBase<KbqSelectValue[]> implements OnInit {
+    /** @docs-private */
+    readonly tree: _angular_core.Signal<KbqTreeSelection>;
+    /** selected value */
+    get selected(): KbqSelectValue[] | null;
+    /** Whether the current pipe is empty. */
+    get isEmpty(): boolean;
+    get selectAllCheckboxState(): KbqPseudoCheckboxState;
+    get numberOfSelectedLeaves(): number;
+    /** true if all options selected */
+    get allOptionsSelected(): boolean;
+    get selectedAllEqualsSelectedNothing(): boolean;
+    /** true if all visible options selected */
+    get allVisibleOptionsSelected(): boolean;
+    private readonly multiSelect;
+    constructor();
+    ngOnInit(): void;
+    isNodeSelectAll(_: number, nodeData: KbqTreeSelectFlatNode): boolean;
+    onSelect({ value: option }: {
+        value: any;
+    }): void;
+    searchKeydownHandler(): void;
+    toggleSelectAllNode(emitEvent?: boolean): void;
+    /**
+     * Populates the tree data source from the pipe template. The shared `values`/`valueTemplate`
+     * assignment is already performed by the base subscription, so this override only does the
+     * tree-specific work and avoids a redundant double assignment.
+     */
+    updateTemplates: (templates: KbqPipeTemplate[] | null) => void;
+    onClear(): void;
+    /** @docs-private */
+    onClose(): void;
+    /** handler for select all options in select */
+    selectAllHandler: (event: KeyboardEvent) => void;
+    private toggleParents;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeMultiTreeSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPipeMultiTreeSelectComponent, "kbq-pipe-multi-tree-select", never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqPipeReadonlyComponent extends KbqBasePipe<string | null> {
+    open(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeReadonlyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPipeReadonlyComponent, "kbq-pipe-readonly", never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqPipeSelectComponent extends KbqBasePipe<KbqSelectValue> implements AfterViewInit, OnInit {
+    /** control for search options */
+    readonly searchControl: FormControl<string | null>;
+    /** filtered by search options */
+    filteredOptions: Observable<KbqSelectValue[]>;
+    /** @docs-private */
+    readonly select: _angular_core.Signal<KbqSelect>;
+    /** selected value */
+    get selected(): KbqSelectValue | null;
+    /** Whether the current pipe is empty. */
+    get isEmpty(): boolean;
+    /** @docs-private */
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    onSelect(item: KbqSelectValue): void;
+    /** Comparator of selected options */
+    compareByValue: (o1: Pick<KbqSelectValue, "id"> | null, o2: Pick<KbqSelectValue, "id"> | null) => boolean;
+    /** opens select */
+    open(): void;
+    private getFilteredOptions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPipeSelectComponent, "kbq-pipe-select", never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqPipeTextComponent extends KbqBasePipe<string | null> implements AfterViewInit, OnInit {
+    readonly placements: typeof PopUpPlacements;
+    /** @docs-private */
+    readonly popover: _angular_core.Signal<KbqPopoverTrigger>;
+    /** Whether the current pipe is disabled. */
+    get disabled(): boolean;
+    /** textarea control */
+    control: FormControl<string | null>;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    onApply(): void;
+    /** @docs-private */
+    onKeydown($event: KeyboardEvent): void;
+    /** clears the pipe and triggers changes */
+    onClear(): void;
+    /** opens popover */
+    open(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeTextComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPipeTextComponent, "kbq-pipe-text", never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqPipeTreeSelectComponent extends KbqTreeSelectPipeBase<KbqSelectValue> {
+    /** selected value */
+    get selected(): KbqSelectValue | null;
+    /** Whether the current pipe is empty. */
+    get isEmpty(): boolean;
+    constructor();
+    onSelect(item: KbqTreeOption): void;
+    /**
+     * Populates the tree data source from the pipe template. The shared `values`/`valueTemplate`
+     * assignment is already performed by the base subscription, so this override only does the
+     * tree-specific work and avoids a redundant double assignment.
+     */
+    updateTemplates: (templates: KbqPipeTemplate[] | null) => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeTreeSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPipeTreeSelectComponent, "kbq-pipe-tree-select", never, {}, {}, never, never, true, never>;
+}
+
+export { KBQ_FILTER_BAR_CONFIGURATION, KBQ_FILTER_BAR_DEFAULT_CONFIGURATION, KBQ_FILTER_BAR_HOST, KBQ_FILTER_BAR_PIPES, KBQ_PIPE_DATA, KbqBasePipe, KbqFilterBar, KbqFilterBarButton, KbqFilterBarModule, KbqFilterRefresher as KbqFilterBarRefresher, KbqFilterRefresher, KbqFilterReset, KbqFilterSavePopover, KbqFilters, KbqPipeAdd, KbqPipeButton, KbqPipeDateBaseComponent, KbqPipeDateComponent, KbqPipeDatetimeComponent, KbqPipeDirective, KbqPipeMinWidth, KbqPipeMultiSelectComponent, KbqPipeMultiTreeSelectComponent, KbqPipeReadonlyComponent, KbqPipeSelectComponent, KbqPipeState, KbqPipeTextComponent, KbqPipeTreeSelectComponent, KbqPipeTypes, KbqSaveFilterStatuses, KbqTreeSelectFlatNode, KbqTreeSelectPipeBase, defaultFilterBarPipes, getId, kbqBuildTree, kbqFilterBarPipesProvider };
+export type { KbqDateTimeValue, KbqFilter, KbqFilterBarConfiguration, KbqFilterBarHost, KbqPipe, KbqPipeData, KbqPipeTemplate, KbqPipeType, KbqSaveFilterError, KbqSaveFilterEvent, KbqSelectValue, KbqTreeSelectNode };