@koobiq/components 20.0.0 → 20.2.0

package/filter-bar/index.d.ts

@@ -1,20 +1,125 @@
-import * as i0 from '@angular/core';
-import { TemplateRef, InjectionToken, Provider, OnInit, ElementRef, DestroyRef, ChangeDetectorRef, EventEmitter, AfterContentInit, AfterViewInit, OnDestroy } from '@angular/core';
+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, KbqPseudoCheckboxState } from '@koobiq/components/core';
-import { Observable, BehaviorSubject, Subject } from 'rxjs';
+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 { UntypedFormControl, FormControl, FormGroup } from '@angular/forms';
+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 { KbqTooltipTrigger } from '@koobiq/components/tooltip';
 import { KbqListSelection } from '@koobiq/components/list';
-import { FlatTreeControl, KbqTreeFlattener, KbqTreeFlatDataSource, KbqTreeOption } from '@koobiq/components/tree';
+import { KbqInput } from '@koobiq/components/input';
+import { FlatTreeControl, KbqTreeFlattener, KbqTreeFlatDataSource, KbqTreeSelection, KbqTreeOption } from '@koobiq/components/tree';
 import { KbqTreeSelect } from '@koobiq/components/tree-select';
 
-/**default configuration of filter-bar */
+/** 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;
+    /**
+     * Optional equality comparator forwarded from the pipe template to the underlying `kbq-select`.
+     * Only consumed by the select / multi-select pipe components; when unset they fall back to their
+     * own id-based `compareByValue`.
+     */
+    protected optionCompareWith?: (o1: KbqSelectValue | null | undefined, o2: KbqSelectValue | null | undefined) => boolean;
+    /**
+     * 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;
@@ -39,9 +144,15 @@ declare const KBQ_FILTER_BAR_DEFAULT_CONFIGURATION: {
         errorHint: string;
         saveButton: string;
         cancelButton: string;
+        actionsTooltip: string;
     };
     add: {
         tooltip: string;
+        addedAnnouncement: string;
+    };
+    refresher: {
+        refresh: string;
+        settings: string;
     };
     pipe: {
         clearButtonTooltip: string;
@@ -58,16 +169,118 @@ declare const KBQ_FILTER_BAR_DEFAULT_CONFIGURATION: {
         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<unknown>;
+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<any>;
+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",
+    /** Renders a bare input: no popover, never opens. Commits while typing (debounced), on Enter and on blur. */
+    Input = "input",
     Select = "select",
     TreeSelect = "tree-select",
     MultiSelect = "multiselect",
@@ -75,9 +288,9 @@ declare enum KbqPipeTypes {
     Date = "date",
     Datetime = "datetime"
 }
-type KbqPipeType = `${KbqPipeTypes}` | string;
+type KbqPipeType = `${KbqPipeTypes}` | (string & {});
 /** list of pipes available out of the box. */
-declare const defaultFilterBarPipes: [string, unknown][];
+declare const defaultFilterBarPipes: [KbqPipeType, Type<KbqBasePipe<unknown>>][];
 interface KbqDateTimeValue {
     name?: string;
     start?: string;
@@ -86,6 +299,8 @@ interface KbqDateTimeValue {
 interface KbqSelectValue {
     name: string;
     value: unknown;
+    /** Optional stable identifier used by the select/multi-select pipe comparators. */
+    id?: string | number;
 }
 interface KbqFilter {
     name: string;
@@ -121,6 +336,12 @@ interface KbqPipeData<V> extends KbqPipe {
 interface KbqPipeTemplate extends Omit<KbqPipe, 'value'> {
     values?: unknown[];
     valueTemplate?: TemplateRef<any> | string;
+    /**
+     * Custom equality comparator forwarded to the underlying `kbq-select` of the `select` /
+     * `multiselect` pipes. When omitted, the pipe's default id-based comparator (`compareByValue`)
+     * is used. Ignored by other pipe types.
+     */
+    compareWith?: (o1: KbqSelectValue | null | undefined, o2: KbqSelectValue | null | undefined) => boolean;
 }
 interface KbqSaveFilterError {
     text?: string;
@@ -154,19 +375,96 @@ interface KbqTreeSelectNode {
  * 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: any, level: number): T[];
+declare function kbqBuildTree<T extends KbqTreeSelectNode>(value: Record<string, unknown>, level: number): T[];
 
 declare class KbqFilterReset {
-    /** KbqFilterBar instance */
+    /** KbqFilterBar host seam */
     private readonly filterBar;
     /** Event that is generated whenever the user reset a filter. */
-    readonly onResetFilter: i0.OutputEmitterRef<KbqFilter | null>;
+    readonly onResetFilter: _angular_core.OutputEmitterRef<KbqFilter | null>;
     /** localized data
      * @docs-private */
-    get localeData(): any;
+    get localeData(): string;
     protected resetFilter(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqFilterReset, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqFilterReset, "kbq-filter-reset", never, {}, { "onResetFilter": "onResetFilter"; }, never, ["*"], true, never>;
+    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;
+    /** Custom error text passed to `showError()`; `null` when the locale-derived default should be used. */
+    private customErrorText;
+    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;
+    };
+    /** Filter saving error text (custom or locale-derived).
+     * @docs-private */
+    get filterSavingErrorText(): 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 {
@@ -187,79 +485,89 @@ declare class KbqFilters implements OnInit {
     /** @docs-private */
     private readonly changeDetectorRef;
     /** @docs-private */
-    protected readonly mainButton: i0.Signal<KbqButton>;
+    protected readonly mainButton: _angular_core.Signal<KbqButton>;
     /** @docs-private */
-    protected readonly saveNewFilterButton: i0.Signal<KbqButton>;
+    protected readonly saveNewFilterButton: _angular_core.Signal<KbqButton>;
     /** @docs-private */
-    protected readonly filterActionsButton: i0.Signal<KbqButton>;
+    protected readonly filterActionsButton: _angular_core.Signal<KbqButton>;
     /** @docs-private */
-    protected readonly popover: i0.Signal<KbqPopoverTrigger>;
+    protected readonly popover: _angular_core.Signal<KbqPopoverTrigger>;
     /** @docs-private */
-    protected readonly dropdown: i0.Signal<KbqDropdownTrigger>;
+    protected readonly dropdown: _angular_core.Signal<KbqDropdownTrigger>;
     /** @docs-private */
-    protected readonly filterActionsDropdown: i0.Signal<KbqDropdownTrigger | undefined>;
+    protected readonly filterActionsDropdown: _angular_core.Signal<KbqDropdownTrigger | undefined>;
+    /** @docs-private */
+    protected readonly savePopover: _angular_core.Signal<KbqFilterSavePopover>;
     private readonly search;
-    private readonly newFilterName;
-    private readonly saveFilterButton;
     /** control for search filter */
-    searchControl: UntypedFormControl;
+    readonly searchControl: FormControl<string | null>;
     /** filtered by search filters */
     filteredOptions: Observable<KbqFilter[]>;
     /** @docs-private */
-    popoverSize: PopUpSizes;
+    protected readonly popoverSize = PopUpSizes.Medium;
     /** @docs-private */
-    popoverOffset: number;
-    /** 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;
-    readonly filters: i0.InputSignal<KbqFilter[]>;
+    protected readonly popoverOffset: number;
+    readonly filters: _angular_core.InputSignal<KbqFilter[]>;
     /** Event that is generated whenever the user selects a filter. */
-    readonly onSelectFilter: i0.OutputEmitterRef<KbqFilter>;
-    /** Event that is generated whenever the user save a filter. */
-    readonly onSave: i0.OutputEmitterRef<KbqSaveFilterEvent>;
+    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: i0.OutputEmitterRef<KbqSaveFilterEvent>;
+    readonly onChangeFilter: _angular_core.OutputEmitterRef<KbqSaveFilterEvent>;
     /** Event that is generated whenever the user remove a filter. */
-    readonly onRemoveFilter: i0.OutputEmitterRef<KbqFilter>;
+    readonly onRemoveFilter: _angular_core.OutputEmitterRef<KbqFilter>;
     /** Event that is generated whenever the user reset a filter changes. */
-    readonly onResetFilterChanges: i0.OutputEmitterRef<KbqFilter | null>;
-    /** header of popover. Depends on the mode */
-    get popoverHeader(): string;
+    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 */
+    /** 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(): any;
+    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;
-    constructor();
     ngOnInit(): void;
     /** @docs-private */
     focusedElementBeforeIs(button: KbqButton): boolean;
     selectFilter(filter: KbqFilter): void;
     saveChanges(): void;
-    saveAsNew(event?: Event): void;
-    showError(error?: KbqSaveFilterError): void;
     restoreFocus(): void;
-    preparePopover(): void;
-    openSaveAsNewFilterPopover(): void;
-    openChangeFilterNamePopover(): void;
     /** @docs-private */
     saveFocusedElement(button?: KbqButton): void;
-    closePopover: (restoreFocus?: boolean) => void;
+    /** Restore focus when the save popover reports it closed. @docs-private */
+    onSavePopoverClosed(restoreFocus: boolean): void;
     /** @docs-private */
     stopEventPropagation(event: Event): void;
     /** @docs-private */
@@ -273,64 +581,142 @@ declare class KbqFilters implements OnInit {
     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: i0.ɵɵFactoryDeclaration<KbqFilters, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqFilters, "kbq-filters", ["kbqFilters"], { "filters": { "alias": "filters"; "required": false; "isSignal": true; }; }, { "onSelectFilter": "onSelectFilter"; "onSave": "onSave"; "onChangeFilter": "onChangeFilter"; "onRemoveFilter": "onRemoveFilter"; "onResetFilterChanges": "onResetFilterChanges"; }, never, ["*"], true, never>;
+    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 {
+declare class KbqFilterBar implements KbqFilterBarHost {
     /** @docs-private */
     protected readonly changeDetectorRef: ChangeDetectorRef;
     /** @docs-private */
     protected readonly localeService: _koobiq_components_core.KbqLocaleService | null;
-    readonly externalConfiguration: unknown;
-    configuration: any;
-    /** @docs-private */
-    readonly filters: i0.Signal<KbqFilters | undefined>;
-    /** @docs-private */
-    readonly filterReset: i0.Signal<KbqFilterReset | undefined>;
+    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. */
+    get configuration(): KbqFilterBarConfiguration;
+    set configuration(value: KbqFilterBarConfiguration);
+    private readonly _configuration;
+    /** @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: i0.InputSignalWithTransform<boolean, unknown>;
-    /** Filter that is currently selected */
-    get filter(): KbqFilter | null;
-    set filter(value: KbqFilter | null);
-    private _filter;
-    /** An array of templates that are used when adding a pipe. Also contains lists of options to select (values). */
-    get pipeTemplates(): KbqPipeTemplate[];
-    set pipeTemplates(value: KbqPipeTemplate[]);
-    private _templates;
+    readonly selectedAllEqualsSelectedNothing: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
-     * Event that emits whenever the raw value of the filter changes. This is here primarily
-     * to facilitate the two-way binding for the `filter` input.
-     * @docs-private
+     * 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 filterChange: i0.OutputEmitterRef<KbqFilter | null>;
+    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: EventEmitter<KbqPipe>;
+    readonly onChangePipe: _angular_core.OutputEmitterRef<KbqPipe>;
     /** Event that emits whenever the pipe deleted. */
-    readonly onRemovePipe: i0.OutputEmitterRef<KbqPipe>;
+    readonly onRemovePipe: _angular_core.OutputEmitterRef<KbqPipe>;
     /** Event that emits whenever the pipe cleared. */
-    readonly onClearPipe: i0.OutputEmitterRef<KbqPipe>;
+    readonly onClearPipe: _angular_core.OutputEmitterRef<KbqPipe>;
     /** Event that emits whenever the select or multiselect pipe closed. */
-    readonly onClosePipe: i0.OutputEmitterRef<KbqPipe>;
-    /** Whether the current filter is saved and changed */
-    get isSavedAndChanged(): boolean;
+    readonly onClosePipe: _angular_core.OutputEmitterRef<KbqPipe>;
     /** Whether the current filter is saved */
-    get isSaved(): boolean;
+    readonly isSaved: _angular_core.Signal<boolean>;
     /** Whether the current filter is changed */
-    get isChanged(): boolean;
+    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 */
-    get isReadOnly(): boolean;
+    readonly isReadOnly: _angular_core.Signal<boolean>;
     /** Whether the current filter is disabled */
-    get isDisabled(): boolean;
+    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>;
-    /** all changes */
-    readonly changes: BehaviorSubject<void>;
     /** internal filter changes */
     readonly internalFilterChanges: BehaviorSubject<KbqFilter | null>;
     /** internal changes in templates */
@@ -341,48 +727,118 @@ declare class KbqFilterBar {
     constructor();
     /** Remove pipe from current filter and emit event */
     removePipe(pipe: KbqPipe): void;
-    /** Save current state of filter */
+    /**
+     * 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 */
+    /**
+     * 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: i0.ɵɵFactoryDeclaration<KbqFilterBar, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqFilterBar, "kbq-filter-bar, [kbq-filter-bar]", never, { "selectedAllEqualsSelectedNothing": { "alias": "selectedAllEqualsSelectedNothing"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; }; "pipeTemplates": { "alias": "pipeTemplates"; "required": false; }; }, { "filterChange": "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>;
+    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 instance */
+    /** KbqFilterBar host seam */
     private readonly filterBar;
     /** KbqFilters instance */
     protected readonly filters: KbqFilters;
     constructor();
     /** @docs-private */
     saveFocusedElement(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqFilterBarButton, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqFilterBarButton, "[kbqFilterBarButton]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqFilterBarButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqFilterBarButton, "[kbqFilterBarButton]", never, {}, {}, never, never, true, never>;
 }
 
-declare class KbqFilterBarRefresher {
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqFilterBarRefresher, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqFilterBarRefresher, "kbq-filter-refresher, [kbq-filter-refresher]", 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: KbqFilterBar;
+    protected readonly filterBar: KbqFilterBarHost;
     /** @docs-private */
-    readonly select: i0.Signal<KbqSelect>;
+    readonly select: _angular_core.Signal<KbqSelect>;
     /** Event that is generated after add pipe. */
-    readonly onAddPipe: i0.OutputEmitterRef<KbqPipeTemplate>;
+    readonly onAddPipe: _angular_core.OutputEmitterRef<KbqPipeTemplate>;
     /** template of filter */
-    readonly filterTemplate: i0.InputSignal<KbqFilter>;
-    /** already added pipes. Used to open an already added pipe. */
-    addedPipes: (string | number)[];
-    constructor();
+    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
@@ -390,135 +846,45 @@ declare class KbqPipeAdd {
      * should be returned.
      */
     compareWith(o1: KbqPipe, o2: string): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqPipeAdd, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqPipeAdd, "kbq-pipe-add", never, { "filterTemplate": { "alias": "filterTemplate"; "required": false; "isSignal": true; }; }, { "onAddPipe": "onAddPipe"; }, never, never, true, never>;
+    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: i0.InputSignal<T>;
+    readonly pipe: _angular_core.InputSignal<T>;
     ngAfterContentInit(): void;
     private getInjector;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqPipeDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqPipeDirective<any>, "[kbqPipe]", never, { "pipe": { "alias": "kbqPipe"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-/** 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: KbqFilterBar | null;
-    /** @docs-private */
-    protected readonly changeDetectorRef: ChangeDetectorRef;
-    /** @docs-private */
-    protected readonly destroyRef: DestroyRef;
-    /** 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(): any;
-    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;
-    /** @docs-private */
-    abstract open(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqBasePipe<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqBasePipe<any>, never, never, {}, {}, never, never, true, never>;
-}
-declare class KbqPipeMinWidth {
-    /** KbqFilterBar instance */
-    protected readonly filterBar: KbqFilterBar | 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;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqPipeMinWidth, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqPipeMinWidth, "[kbqPipeMinWidth]", never, {}, {}, never, never, true, never>;
+    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: KbqFilterBar;
+    protected readonly filterBar: KbqFilterBarHost;
     /** @docs-private */
     protected readonly changeDetectorRef: ChangeDetectorRef;
     /** enables/disables read-only state */
-    readonly readonly: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** localized data
      * @docs-private */
-    get localeData(): any;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqPipeButton, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqPipeButton, "kbq-pipe-button", never, { "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-declare class KbqPipeTitleDirective extends KbqTooltipTrigger implements AfterViewInit, OnDestroy {
-    private componentInstance;
-    get isOverflown(): boolean;
-    readonly viewValue: i0.InputSignal<TemplateRef<any>>;
-    get parent(): HTMLElement;
-    get child(): HTMLElement;
-    readonly resizeStream: Subject<Event>;
-    private readonly debounceInterval;
-    private resizeSubscription;
-    private mutationSubscription;
-    private focusMonitorSubscription;
-    private childContainer;
-    private parentContainer;
+    get localeData(): {
+        clearButtonTooltip: string;
+        removeButtonTooltip: string;
+        applyButton: string;
+        emptySearchResult: string;
+        selectAll: string;
+    };
     constructor();
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-    handleElementEnter(): void;
-    hideTooltip(): void;
-    private listenToMutationObserver;
-    private createMutationObserver;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqPipeTitleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqPipeTitleDirective, "[kbqPipeTitle]", ["kbqPipeTitle"], { "viewValue": { "alias": "kbqPipeTitle"; "required": false; "isSignal": true; }; }, {}, ["parentContainer", "childContainer"], never, true, never>;
+    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> implements OnInit {
-    /** @docs-private */
-    private readonly destroyRef;
+declare class KbqPipeState<T> {
     /** @docs-private */
     private readonly button;
     /** @docs-private */
@@ -526,25 +892,29 @@ declare class KbqPipeState<T> implements OnInit {
     /** KbqFilterBar instance
      * @docs-private */
     private readonly filterBar;
-    /** calculates and updates styles of button from pipe state */
-    get state(): T | null;
-    set state(pipe: T | null);
-    private _state;
-    ngOnInit(): void;
+    /** Pipe state used to calculate/update the button style. */
+    readonly state: _angular_core.InputSignal<T | null>;
+    constructor();
     private updateState;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqPipeState<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqPipeState<any>, "[kbqPipeState]", never, { "state": { "alias": "kbqPipeState"; "required": false; }; }, {}, never, never, true, never>;
+    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: i0.ɵɵFactoryDeclaration<KbqFilterBarModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqFilterBarModule, never, [typeof KbqFilterBar, typeof KbqFilters, typeof KbqFilterBarRefresher, typeof KbqFilterBarButton, typeof KbqFilterReset, typeof KbqPipeAdd, typeof KbqPipeDirective, typeof KbqPipeButton, typeof KbqPipeTitleDirective, typeof KbqPipeState], [typeof KbqFilterBar, typeof KbqFilters, typeof KbqFilterBarRefresher, typeof KbqFilterBarButton, typeof KbqFilterReset, typeof KbqPipeAdd, typeof KbqPipeDirective, typeof KbqPipeButton, typeof KbqPipeTitleDirective, typeof KbqPipeState]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<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>;
 }
 
-declare class KbqPipeDateComponent<D> extends KbqBasePipe<KbqDateTimeValue> implements AfterViewInit {
-    private readonly adapter;
-    private readonly formatter;
+/**
+ * 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 */
@@ -559,6 +929,12 @@ declare class KbqPipeDateComponent<D> extends KbqBasePipe<KbqDateTimeValue> impl
     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. */
@@ -573,12 +949,6 @@ declare class KbqPipeDateComponent<D> extends KbqBasePipe<KbqDateTimeValue> impl
     get defaultEnd(): D;
     /** Whether the current pipe is empty. */
     get isEmpty(): boolean;
-    /** @docs-private */
-    readonly popover: i0.Signal<KbqPopoverTrigger>;
-    /** @docs-private */
-    listSelection: i0.Signal<KbqListSelection>;
-    /** @docs-private */
-    returnButton: i0.Signal<KbqButton>;
     ngAfterViewInit(): void;
     /** keydown handler
      * @docs-private */
@@ -594,78 +964,80 @@ declare class KbqPipeDateComponent<D> extends KbqBasePipe<KbqDateTimeValue> impl
     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: i0.ɵɵFactoryDeclaration<KbqPipeDateComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqPipeDateComponent<any>, "kbq-pipe-date", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeDateBaseComponent<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqPipeDateBaseComponent<any>, never, never, {}, {}, never, never, true, never>;
 }
 
-declare class KbqPipeDatetimeComponent<D> extends KbqBasePipe<KbqDateTimeValue> implements AfterViewInit {
-    private readonly adapter;
-    private readonly formatter;
-    /** @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;
+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 KbqPipeInputComponent extends KbqBasePipe<string | null> implements OnInit {
     /** @docs-private */
-    protected showEndCalendar: boolean;
-    /** 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. */
+    protected readonly input: _angular_core.Signal<KbqInput>;
+    /**
+     * Input control.
+     *
+     * Must stay nullable: `reset()` — all `KbqFormField.clearValue()` and its Escape handler ever call —
+     * resolves to `defaultValue`, which is `null` only while `nonNullable` is unset. `{ nonNullable: true }`
+     * would make `reset()` yield `''` and silently break the cleaner bridge below.
+     */
+    readonly control: FormControl<string | null>;
+    /**
+     * Debounce in milliseconds between the last keystroke and the typed value being applied to the filter.
+     * Matches `defaultEmitValueTimeout` of `kbq-search-expandable`, so both search fields of a bar feel the
+     * same. `Enter` and blur apply immediately and cancel a pending apply.
+     */
+    debounceTime: number;
+    /**
+     * Minimum number of characters before typing applies the value to the filter. Anything shorter —
+     * including an emptied field — is applied as `null`, so the filter never keeps text the user has
+     * already erased. `Enter` and blur ignore the threshold. Set to `0` to apply every keystroke.
+     */
+    minLength: number;
+    /** Cancels a pending debounced apply once the value has been applied (or cleared) through another path. */
+    private readonly cancelPendingApply;
+    /** Whether the current pipe is empty. Used for apply style modifier */
     get isEmpty(): boolean;
-    /** @docs-private */
-    readonly popover: i0.Signal<KbqPopoverTrigger>;
-    /** @docs-private */
-    listSelection: i0.Signal<KbqListSelection>;
-    /** @docs-private */
-    returnButton: i0.Signal<KbqButton>;
-    ngAfterViewInit(): void;
-    /** keydown handler
-     * @docs-private */
-    onKeydown($event: KeyboardEvent): void;
-    /** @docs-private */
-    onApplyPeriod(): void;
-    onSelect(item: KbqDateTimeValue): void;
-    showPeriod(): void;
-    showList(): void;
-    /** opens popover */
+    ngOnInit(): void;
+    /** clears the pipe and triggers changes */
+    onClear(): void;
+    /** focuses the input */
     open(): void;
-    onSelectStartDate(value: D): void;
-    onSelectEndDate(value: D): void;
-    onFocusStartInput(): void;
-    onFocusEndInput(): void;
-    hideCalendars(): void;
-    private initFormGroup;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqPipeDatetimeComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqPipeDatetimeComponent<any>, "kbq-pipe-datetime", never, {}, {}, never, never, true, never>;
+    /** Commits a value to `data` and notifies the filter-bar. */
+    private commit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqPipeInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqPipeInputComponent, "kbq-pipe-input", never, {}, {}, never, never, true, never>;
 }
 
 declare class KbqPipeMultiSelectComponent extends KbqBasePipe<KbqSelectValue[]> implements AfterViewInit, OnInit {
     /** control for search options */
-    searchControl: UntypedFormControl;
+    readonly searchControl: FormControl<string | null>;
     /** filtered by search options */
-    filteredOptions: Observable<any[]>;
+    filteredOptions: Observable<KbqSelectValue[]>;
     /** @docs-private */
-    readonly select: i0.Signal<KbqSelect>;
+    readonly select: _angular_core.Signal<KbqSelect>;
     /** @docs-private */
-    readonly options: i0.Signal<readonly KbqOption[]>;
+    readonly options: _angular_core.Signal<readonly KbqOption[]>;
     /** selected value */
     get selected(): KbqSelectValue[] | null;
     /** Whether the current pipe is empty. */
@@ -679,7 +1051,7 @@ declare class KbqPipeMultiSelectComponent extends KbqBasePipe<KbqSelectValue[]>
     get selectedAllEqualsSelectedNothing(): boolean;
     private get visibleOptions();
     private selectionAllInProgress;
-    private internalSelected;
+    private readonly multiSelect;
     /** @docs-private */
     ngOnInit(): void;
     ngAfterViewInit(): void;
@@ -691,34 +1063,108 @@ declare class KbqPipeMultiSelectComponent extends KbqBasePipe<KbqSelectValue[]>
     toggleSelectionAllByEnterKey(): void;
     /** @docs-private */
     toggleSelectionAll(emitEvent?: boolean): void;
-    /** Comparator of selected options */
-    compareByValue: (o1: any, o2: any) => boolean;
+    /** 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 updateInternalSelected;
-    private emitChangePipeEvent;
     private getFilteredOptions;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqPipeMultiSelectComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqPipeMultiSelectComponent, "kbq-pipe-multi-select", never, {}, {}, never, never, true, never>;
+    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: i0.ɵɵFactoryDeclaration<KbqPipeReadonlyComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqPipeReadonlyComponent, "kbq-pipe-readonly", never, {}, {}, never, never, true, never>;
+    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 */
-    searchControl: UntypedFormControl;
+    readonly searchControl: FormControl<string | null>;
     /** filtered by search options */
-    filteredOptions: Observable<any[]>;
+    filteredOptions: Observable<KbqSelectValue[]>;
     /** @docs-private */
-    readonly select: i0.Signal<KbqSelect>;
+    readonly select: _angular_core.Signal<KbqSelect>;
     /** selected value */
     get selected(): KbqSelectValue | null;
     /** Whether the current pipe is empty. */
@@ -728,18 +1174,18 @@ declare class KbqPipeSelectComponent extends KbqBasePipe<KbqSelectValue> impleme
     ngAfterViewInit(): void;
     onSelect(item: KbqSelectValue): void;
     /** Comparator of selected options */
-    compareByValue: (o1: any, o2: any) => boolean;
+    compareByValue: (o1: Pick<KbqSelectValue, "id"> | null, o2: Pick<KbqSelectValue, "id"> | null) => boolean;
     /** opens select */
     open(): void;
     private getFilteredOptions;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqPipeSelectComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqPipeSelectComponent, "kbq-pipe-select", never, {}, {}, never, never, true, never>;
+    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: i0.Signal<KbqPopoverTrigger>;
+    readonly popover: _angular_core.Signal<KbqPopoverTrigger>;
     /** Whether the current pipe is disabled. */
     get disabled(): boolean;
     /** textarea control */
@@ -753,44 +1199,26 @@ declare class KbqPipeTextComponent extends KbqBasePipe<string | null> implements
     onClear(): void;
     /** opens popover */
     open(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqPipeTextComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqPipeTextComponent, "kbq-pipe-text", never, {}, {}, never, never, true, never>;
+    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 KbqBasePipe<KbqSelectValue> implements OnInit, AfterViewInit {
-    /** control for search options */
-    searchControl: UntypedFormControl;
-    /** filtered by search options */
-    filteredOptions: Observable<any[]>;
-    treeControl: FlatTreeControl<KbqTreeSelectFlatNode>;
-    treeFlattener: KbqTreeFlattener<KbqTreeSelectNode, KbqTreeSelectFlatNode>;
-    dataSource: KbqTreeFlatDataSource<KbqTreeSelectNode, KbqTreeSelectFlatNode>;
-    template: any;
-    /** @docs-private */
-    readonly select: i0.Signal<KbqTreeSelect>;
+declare class KbqPipeTreeSelectComponent extends KbqTreeSelectPipeBase<KbqSelectValue> {
     /** selected value */
     get selected(): KbqSelectValue | null;
     /** Whether the current pipe is empty. */
     get isEmpty(): boolean;
     constructor();
-    ngOnInit(): void;
-    ngAfterViewInit(): void;
-    hasChild(_: number, nodeData: any): any;
     onSelect(item: KbqTreeOption): void;
-    /** updates values for selection and value template */
+    /**
+     * 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;
-    /** opens select */
-    open(): void;
-    onOpen(): void;
-    private transformer;
-    private getLevel;
-    private isExpandable;
-    private getChildren;
-    private getValue;
-    private getViewValue;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqPipeTreeSelectComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqPipeTreeSelectComponent, "kbq-pipe-tree-select", never, {}, {}, never, never, true, never>;
+    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_PIPES, KBQ_PIPE_DATA, KbqBasePipe, KbqFilterBar, KbqFilterBarButton, KbqFilterBarModule, KbqFilterBarRefresher, KbqFilterReset, KbqFilters, KbqPipeAdd, KbqPipeButton, KbqPipeDateComponent, KbqPipeDatetimeComponent, KbqPipeDirective, KbqPipeMinWidth, KbqPipeMultiSelectComponent, KbqPipeReadonlyComponent, KbqPipeSelectComponent, KbqPipeState, KbqPipeTextComponent, KbqPipeTitleDirective, KbqPipeTreeSelectComponent, KbqPipeTypes, KbqSaveFilterStatuses, KbqTreeSelectFlatNode, defaultFilterBarPipes, getId, kbqBuildTree, kbqFilterBarPipesProvider };
-export type { KbqDateTimeValue, KbqFilter, KbqPipe, KbqPipeData, KbqPipeTemplate, KbqPipeType, KbqSaveFilterError, KbqSaveFilterEvent, KbqSelectValue, KbqTreeSelectNode };
+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, KbqPipeInputComponent, 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 };