@koobiq/components 19.8.0 → 20.0.0

package/timezone/index.d.ts

@@ -1 +1,122 @@
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { ElementRef, AfterViewInit, OnDestroy, AfterContentInit, PipeTransform } from '@angular/core';
+import * as i2 from '@koobiq/components/core';
+import { KbqOption } from '@koobiq/components/core';
+import * as i6 from '@koobiq/components/tooltip';
+import { KbqTooltipTrigger } from '@koobiq/components/tooltip';
+import * as i3 from '@koobiq/components/select';
+import { KbqSelect, KbqSelectPanelWidth } from '@koobiq/components/select';
+import * as i1 from '@angular/cdk/overlay';
+import * as i4 from '@koobiq/components/icon';
+import * as i5 from '@koobiq/components/tags';
+import * as i7 from '@angular/common';
+import * as i8 from '@angular/cdk/a11y';
+import * as i14 from '@koobiq/components/form-field';
+
+interface KbqTimezoneZone {
+    id: string;
+    offset: string;
+    city: string;
+    countryCode: string;
+    countryName: string;
+    cities: string;
+}
+interface KbqTimezoneGroup {
+    countryName: string;
+    countryCode: string;
+    zones: KbqTimezoneZone[];
+}
+interface KbqTimezonesByCountry {
+    [countryName: string]: KbqTimezoneZone[];
+}
+
+declare class KbqTimezoneOption extends KbqOption {
+    readonly tooltipContentWrapper: i0.Signal<ElementRef<HTMLElement>>;
+    readonly tooltipContent: i0.Signal<ElementRef<HTMLElement>>;
+    readonly highlightText: i0.InputSignal<string>;
+    get timezone(): KbqTimezoneZone;
+    set timezone(zone: KbqTimezoneZone);
+    private _timezone;
+    get viewValue(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTimezoneOption, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTimezoneOption, "kbq-timezone-option", ["kbqTimezoneOption"], { "highlightText": { "alias": "highlightText"; "required": false; "isSignal": true; }; "timezone": { "alias": "timezone"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const TOOLTIP_VISIBLE_ROWS_COUNT = 3;
+declare class KbqTimezoneOptionTooltip extends KbqTooltipTrigger implements AfterViewInit, OnDestroy {
+    private readonly option;
+    private readonly changeDetectorRef;
+    private readonly resizeObserver;
+    private readonly contentObserver;
+    private readonly debounceInterval;
+    private resizeSubscription;
+    private contentObserverSubscription;
+    private focusMonitorSubscription;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    handleElementEnter(): void;
+    handleElementLeave(): void;
+    private checkTooltipDisabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTimezoneOptionTooltip, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTimezoneOptionTooltip, "kbq-timezone-option", never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqTimezoneSelectTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTimezoneSelectTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTimezoneSelectTrigger, "kbq-timezone-select-trigger", never, {}, {}, never, never, true, never>;
+}
+declare class KbqTimezoneSelect extends KbqSelect implements AfterContentInit {
+    readonly customTrigger: i0.Signal<KbqTimezoneSelectTrigger | undefined>;
+    panelWidth: KbqSelectPanelWidth;
+    panelMinWidth: number;
+    ngAfterContentInit(): void;
+    private updateLocaleParamsForSearch;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTimezoneSelect, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTimezoneSelect, "kbq-timezone-select", ["kbqTimezoneSelect"], {}, {}, ["customTrigger"], ["kbq-timezone-select-trigger", "kbq-cleaner", "[kbqSelectSearch]", "[kbq-select-search-empty-result]", "*"], true, never>;
+}
+
+declare class UtcOffsetPipe implements PipeTransform {
+    transform(value: string): {
+        [UTC: string]: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtcOffsetPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UtcOffsetPipe, "utcOffset", true>;
+}
+
+declare class CitiesByFilterPipe implements PipeTransform {
+    transform(value: string, searchPattern?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CitiesByFilterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CitiesByFilterPipe, "citiesByFilter", true>;
+}
+
+declare class KbqTimezoneModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTimezoneModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqTimezoneModule, never, [typeof i1.OverlayModule, typeof i2.KbqOptionModule, typeof i3.KbqSelectModule, typeof i4.KbqIconModule, typeof i5.KbqTagsModule, typeof i6.KbqToolTipModule, typeof i2.KbqHighlightModule, typeof i7.KeyValuePipe, typeof i8.A11yModule, typeof UtcOffsetPipe, typeof CitiesByFilterPipe, typeof KbqTimezoneSelect, typeof KbqTimezoneOption, typeof KbqTimezoneOptionTooltip, typeof KbqTimezoneSelectTrigger], [typeof KbqTimezoneSelect, typeof KbqTimezoneOption, typeof KbqTimezoneOptionTooltip, typeof KbqTimezoneSelectTrigger, typeof i14.KbqFormFieldModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqTimezoneModule>;
+}
+
+/**
+ * Convert string timezone offset (formatted offset) to number (minutes)
+ */
+declare function parseOffset(offset: string): number;
+/**
+ * Grouping timezones by countries
+ */
+declare function getZonesGroupedByCountry(data: KbqTimezoneZone[], otherCountriesLabel?: string, priorityCountry?: string): KbqTimezoneGroup[];
+declare function offset(value: any): string;
+declare function offsetFormatter(value: string): string;
+declare function offsetFormatterAsObject(value: string): {
+    [UTC: string]: string;
+};
+/**
+ * Comparator for timezone sorting. Sort by offset and country name
+ */
+declare function timezonesSortComparator(first: KbqTimezoneZone, second: KbqTimezoneZone): number;
+/**
+ * Filtering timezone cities by search string
+ */
+declare function filterCitiesBySearchString(cities: string, searchPattern?: string): string;
+
+export { KbqTimezoneModule, KbqTimezoneOption, KbqTimezoneOptionTooltip, KbqTimezoneSelect, KbqTimezoneSelectTrigger, TOOLTIP_VISIBLE_ROWS_COUNT, filterCitiesBySearchString, getZonesGroupedByCountry, offset, offsetFormatter, offsetFormatterAsObject, parseOffset, timezonesSortComparator };
+export type { KbqTimezoneGroup, KbqTimezoneZone, KbqTimezonesByCountry };

package/title/index.d.ts

@@ -1 +1,41 @@
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy } from '@angular/core';
+import * as i1 from '@koobiq/components/tooltip';
+import { KbqTooltipTrigger } from '@koobiq/components/tooltip';
+import { Subject } from 'rxjs';
+
+declare class KbqTitleDirective extends KbqTooltipTrigger implements AfterViewInit, OnDestroy {
+    private componentInstance;
+    private readonly nativeElement;
+    private contentObserver;
+    set trigger(value: string);
+    get trigger(): string;
+    get isOverflown(): boolean;
+    get isHorizontalOverflown(): boolean;
+    get isVerticalOverflown(): boolean;
+    get viewValue(): string;
+    get parent(): HTMLElement;
+    get child(): HTMLElement;
+    get hasOnlyText(): boolean;
+    readonly resizeStream: Subject<Event>;
+    private readonly debounceInterval;
+    private resizeSubscription;
+    private contentObserverSubscription;
+    private focusMonitorSubscription;
+    private childContainer;
+    private parentContainer;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    handleElementEnter(): void;
+    hideTooltip(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTitleDirective, "[kbq-title]", ["kbqTitle"], {}, {}, ["childContainer", "parentContainer"], never, true, never>;
+}
+
+declare class KbqTitleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTitleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqTitleModule, never, [typeof i1.KbqToolTipModule, typeof KbqTitleDirective], [typeof KbqTitleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqTitleModule>;
+}
+
+export { KbqTitleDirective, KbqTitleModule };

package/toast/index.d.ts

@@ -1 +1,164 @@
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { TemplateRef, InjectionToken, Provider, OnDestroy, ElementRef, ComponentRef, EmbeddedViewRef, ViewContainerRef, ViewRef, Injector } from '@angular/core';
+import { CdkScrollable } from '@angular/cdk/overlay';
+import * as rxjs from 'rxjs';
+import { BehaviorSubject } from 'rxjs';
+import { AnimationEvent } from '@angular/animations';
+import * as i1 from '@koobiq/components/core';
+import { KbqReadStateDirective, ThemePalette } from '@koobiq/components/core';
+
+declare enum KbqToastStyle {
+    Contrast = "contrast",
+    Success = "success",
+    Warning = "warning",
+    Error = "error"
+}
+declare enum KbqToastPosition {
+    TOP_RIGHT = "top-right",
+    TOP_LEFT = "top-left",
+    TOP_CENTER = "top-center",
+    BOTTOM_RIGHT = "bottom-right",
+    BOTTOM_LEFT = "bottom-left",
+    BOTTOM_CENTER = "bottom-center",
+    CENTER = "center"
+}
+declare class KbqToastData {
+    id?: string;
+    title?: string | TemplateRef<any>;
+    style?: KbqToastStyle | string;
+    icon?: TemplateRef<any> | boolean;
+    iconClass?: string;
+    caption?: string | TemplateRef<any>;
+    content?: string | TemplateRef<any>;
+    actions?: TemplateRef<any>;
+    closeButton?: TemplateRef<any> | boolean;
+}
+interface KbqToastConfig {
+    position: KbqToastPosition;
+    duration: number;
+    delay: number;
+    onTop: boolean;
+    /** Custom indentation for positioning the toast stack overlay when using `GlobalPositionStrategy` */
+    indent: {
+        /** Vertical spacing from the top or bottom of the screen. */
+        vertical: number;
+        /** Horizontal spacing from the left or right of the screen. */
+        horizontal: number;
+    };
+}
+declare const defaultToastConfig: KbqToastConfig;
+declare const KBQ_TOAST_CONFIG: InjectionToken<KbqToastConfig>;
+/** Utility provider for `KBQ_TOAST_CONFIG`. */
+declare const kbqToastConfigurationProvider: (configuration: Partial<KbqToastConfig>) => Provider;
+
+declare class KbqToastCloseButton {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqToastCloseButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqToastCloseButton, "[kbq-toast-close-button]", never, {}, {}, never, never, true, never>;
+}
+declare class KbqToastComponent implements OnDestroy {
+    readonly data: KbqToastData;
+    readonly service: KbqToastService<any>;
+    elementRef: ElementRef<HTMLElement>;
+    private focusMonitor;
+    protected readonly readStateDirective: KbqReadStateDirective;
+    themePalette: typeof ThemePalette;
+    animationState: string;
+    readonly hovered: BehaviorSubject<boolean>;
+    readonly focused: BehaviorSubject<boolean>;
+    id: number;
+    ttl: any;
+    delay: any;
+    $implicit: any;
+    get toastStyle(): {
+        [x: string]: boolean;
+    };
+    get isFocusedOrHovered(): boolean;
+    constructor();
+    ngOnDestroy(): void;
+    close(): void;
+    isTemplateRef(value: any): boolean;
+    onAnimation($event: AnimationEvent): void;
+    private runFocusMonitor;
+    private stopFocusMonitor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqToastComponent, "kbq-toast", never, {}, {}, never, never, true, [{ directive: typeof i1.KbqReadStateDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare const KBQ_TOAST_FACTORY: InjectionToken<typeof KbqToastComponent>;
+/** Generic `T` is a type hint only; the runtime component comes from `KBQ_TOAST_FACTORY`. */
+declare class KbqToastService<T extends KbqToastComponent = KbqToastComponent> implements OnDestroy {
+    private overlay;
+    private injector;
+    private overlayContainer;
+    private ngZone;
+    private toastFactory;
+    private toastConfig;
+    get toasts(): ComponentRef<T>[];
+    get templates(): EmbeddedViewRef<T>[];
+    readonly read: BehaviorSubject<KbqToastData | null>;
+    readonly hovered: BehaviorSubject<boolean>;
+    readonly focused: BehaviorSubject<boolean>;
+    readonly animation: BehaviorSubject<AnimationEvent | null>;
+    timer: rxjs.Observable<number>;
+    private containerInstance?;
+    private overlayRef?;
+    private portal?;
+    private timerSubscription;
+    private currentPosition?;
+    private toastsDict;
+    private templatesDict;
+    constructor();
+    ngOnDestroy(): void;
+    show(data: KbqToastData, duration?: number, onTop?: boolean): {
+        ref: ComponentRef<T>;
+        id: number;
+    };
+    showTemplate(data: KbqToastData, template: TemplateRef<any>, duration?: number, onTop?: boolean): {
+        ref: EmbeddedViewRef<T>;
+        id: number;
+    };
+    hide(id: number): void;
+    hideTemplate(id: number): void;
+    private detachOverlay;
+    private processToasts;
+    private updateTTLAfterDelete;
+    private addRemoveTimer;
+    private prepareContainer;
+    private toTop;
+    private createOverlay;
+    private getPositionStrategy;
+    private getTopCenter;
+    private getTopLeft;
+    private getTopRight;
+    private getBottomCenter;
+    private getBottomLeft;
+    private getBottomRight;
+    private getCenter;
+    private getGlobalOverlayPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqToastService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KbqToastService<any>>;
+}
+
+declare class KbqToastContainerComponent extends CdkScrollable {
+    private injector;
+    private changeDetectorRef;
+    readonly service: KbqToastService<any>;
+    readonly viewContainer: i0.Signal<ViewContainerRef>;
+    constructor();
+    createToast<C>(data: KbqToastData, componentType: any, onTop: boolean): ComponentRef<C>;
+    createTemplate<C>(data: KbqToastData, template: TemplateRef<any>, onTop: boolean): EmbeddedViewRef<C>;
+    remove(viewRef: ViewRef): void;
+    getInjector(data: KbqToastData): Injector;
+    dispatchScrollEvent: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqToastContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqToastContainerComponent, "kbq-toast-container", never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqToastModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqToastModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqToastModule, never, [typeof KbqToastComponent, typeof KbqToastCloseButton, typeof KbqToastContainerComponent], [typeof KbqToastComponent, typeof KbqToastCloseButton, typeof KbqToastContainerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqToastModule>;
+}
+
+export { KBQ_TOAST_CONFIG, KBQ_TOAST_FACTORY, KbqToastCloseButton, KbqToastComponent, KbqToastContainerComponent, KbqToastData, KbqToastModule, KbqToastPosition, KbqToastService, KbqToastStyle, defaultToastConfig, kbqToastConfigurationProvider };
+export type { KbqToastConfig };

package/toggle/index.d.ts

@@ -1 +1,84 @@
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, OnDestroy, ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { TransitionCheckState, KbqCheckboxClickAction } from '@koobiq/components/checkbox';
+import { KbqColorDirective, KbqCheckedState } from '@koobiq/components/core';
+import * as i1 from '@angular/cdk/a11y';
+
+type ToggleLabelPositionType = 'left' | 'right';
+declare class KbqToggleChange {
+    source: KbqToggleComponent;
+    checked: boolean;
+}
+declare class KbqToggleComponent extends KbqColorDirective implements AfterViewInit, ControlValueAccessor, OnDestroy {
+    private focusMonitor;
+    private changeDetectorRef;
+    readonly big: _angular_core.InputSignal<boolean>;
+    readonly inputElement: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    readonly labelPosition: _angular_core.InputSignal<ToggleLabelPositionType>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    id: string;
+    get inputId(): string;
+    readonly name: _angular_core.InputSignal<string | null>;
+    readonly value: _angular_core.InputSignal<string>;
+    get disabled(): any;
+    set disabled(value: any);
+    private _disabled;
+    get tabIndex(): number;
+    set tabIndex(value: number);
+    private _tabIndex;
+    get checked(): boolean;
+    set checked(value: boolean);
+    private _checked;
+    /**
+     * Whether the toggle is indeterminate. This is also known as "mixed" mode and can be used to
+     * represent a checkbox with three states, e.g. a checkbox that represents a nested list of
+     * checkable items. Note that whenever checkbox is manually clicked, indeterminate is immediately
+     * set to false.
+     */
+    get indeterminate(): boolean;
+    set indeterminate(value: boolean);
+    private _indeterminate;
+    /**
+     * Property for manually set loading state.
+     */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly change: _angular_core.OutputEmitterRef<KbqToggleChange>;
+    /** Event emitted when the toggle's `indeterminate` value changes. */
+    readonly indeterminateChange: _angular_core.OutputEmitterRef<boolean>;
+    /** @docs-private */
+    protected currentCheckState: TransitionCheckState;
+    /** Defines the behavior when a user clicks on the toggle. */
+    clickAction: KbqCheckboxClickAction;
+    private uniqueId;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    focus(): void;
+    getAriaChecked(): KbqCheckedState;
+    onChangeEvent(event: Event): void;
+    onLabelTextChange(): void;
+    onInputClick(event: MouseEvent): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    private setTransitionCheckState;
+    private onTouchedCallback;
+    private onChangeCallback;
+    private transitionCheckState;
+    private emitChangeEvent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqToggleComponent, "kbq-toggle", ["kbqToggle"], { "big": { "alias": "big"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "clickAction": { "alias": "clickAction"; "required": false; }; }, { "change": "change"; "indeterminateChange": "indeterminateChange"; }, never, ["*", "kbq-hint"], true, never>;
+    static ngAcceptInputType_tabIndex: unknown;
+    static ngAcceptInputType_indeterminate: unknown;
+}
+
+declare class KbqToggleModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqToggleModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqToggleModule, never, [typeof i1.A11yModule, typeof KbqToggleComponent], [typeof KbqToggleComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqToggleModule>;
+}
+
+export { KbqToggleChange, KbqToggleComponent, KbqToggleModule };

package/tooltip/index.d.ts

@@ -1 +1,163 @@
-export * from './public-api';
+import * as rxjs from 'rxjs';
+import * as i0 from '@angular/core';
+import { InjectionToken, ElementRef, AfterViewInit, OnChanges, OnDestroy, Renderer2, WritableSignal, TemplateRef, EventEmitter, SimpleChanges, Type } from '@angular/core';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { ScrollStrategy, Overlay, OverlayConfig } from '@angular/cdk/overlay';
+import { KbqPopUp, KbqPopUpTrigger, KbqParentPopup, KbqPopUpPlacementValues, KbqComponentColors } from '@koobiq/components/core';
+
+declare enum TooltipModifier {
+    Default = "default",
+    Warning = "warning",
+    Extended = "extended"
+}
+declare const KBQ_TOOLTIP_OPEN_TIME: InjectionToken<{
+    value: number;
+}>;
+/** @docs-private */
+declare const KBQ_TOOLTIP_OPEN_TIME_PROVIDER: {
+    provide: InjectionToken<{
+        value: number;
+    }>;
+    useValue: {
+        value: number;
+    };
+};
+declare const MIN_TIME_FOR_DELAY = 2000;
+declare class KbqTooltipComponent extends KbqPopUp {
+    private openTime;
+    prefix: string;
+    elementRef: ElementRef;
+    show(delay: number): void;
+    updateClassMap(placement: string, customClass: string, { modifier }: {
+        modifier: any;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTooltipComponent, "kbq-tooltip-component", never, {}, {}, never, never, true, never>;
+}
+declare const KBQ_TOOLTIP_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/** @docs-private */
+declare function kbqTooltipScrollStrategyFactory(overlay: Overlay): () => ScrollStrategy;
+/** @docs-private */
+declare const KBQ_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof kbqTooltipScrollStrategyFactory;
+};
+declare class KbqTooltipTrigger extends KbqPopUpTrigger<KbqTooltipComponent> implements AfterViewInit, OnChanges, OnDestroy {
+    protected scrollStrategy: () => ScrollStrategy;
+    protected parentPopup: KbqParentPopup | null;
+    protected focusMonitor: FocusMonitor;
+    /** @docs-private */
+    protected renderer: Renderer2;
+    /**
+     * Input for controlling the disabled state of a component.
+     *
+     * The input expects a component containing `disabledSignal` property, which is
+     * a writable signal emitting boolean values.
+     */
+    readonly forDisabledComponent: i0.InputSignal<Record<"disabledSignal", WritableSignal<boolean>> | undefined>;
+    /**
+     * Determines whether pointer events should be ignored on tooltips.
+     *
+     * When set to `true`, tooltip elements will not receive pointer events,
+     * allowing interactions to pass through to underlying elements.
+     * Defaults to `true`.
+     */
+    readonly ignoreTooltipPointerEvents: i0.InputSignal<boolean>;
+    /**
+     * Changes hiding behavior. By default, tooltip is hidden on mouseleave from trigger.
+     * Setting hideWithTimeout to true will delay tooltip hiding and will not hide when the mouse moves from trigger
+     * to tooltip.
+     */
+    hideWithTimeout: boolean;
+    get tooltipVisible(): boolean;
+    set tooltipVisible(value: boolean);
+    get tooltipPlacement(): KbqPopUpPlacementValues;
+    /**
+     * Positions the tooltip relative to the mouse cursor. Only available for top and bottom kbqPlacement.
+     * Does not work with kbqPlacementPriority.
+     */
+    relativeToPointer: boolean;
+    set tooltipPlacement(value: KbqPopUpPlacementValues);
+    get tooltipPlacementPriority(): string | string[] | null;
+    set tooltipPlacementPriority(value: string | string[] | null);
+    get content(): string | TemplateRef<any>;
+    set content(content: string | TemplateRef<any>);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    enterDelay: number;
+    leaveDelay: number;
+    get trigger(): string;
+    set trigger(value: string);
+    protected _trigger: string;
+    get customClass(): string;
+    set customClass(value: string);
+    get context(): any;
+    set context(ctx: any);
+    private _context;
+    get color(): string;
+    set color(value: KbqComponentColors | string);
+    private _color;
+    arrow: boolean;
+    offset: number | null;
+    readonly placementChange: EventEmitter<any>;
+    readonly visibleChange: EventEmitter<boolean>;
+    private get hasClickInTrigger();
+    protected originSelector: string;
+    protected overlayConfig: OverlayConfig;
+    /**
+     * Visual variant of the tooltip. Accepts `'default'` | `'warning'` | `'extended'`.
+     * Replaces the removed `KbqWarningTooltipTrigger` and `KbqExtendedTooltipTrigger`
+     * subclasses — to render a warning tooltip use `kbqTooltipModifier="warning"`,
+     * and `kbqTooltipModifier="extended"` for the extended variant (combine with `kbqTooltipHeader`).
+     */
+    modifier: TooltipModifier | `${TooltipModifier}`;
+    /**
+     * Header text or template, rendered above the tooltip content. Only meaningful with
+     * `kbqTooltipModifier="extended"`. Replaces the removed `KbqExtendedTooltipTrigger.header`.
+     */
+    header: string | TemplateRef<any>;
+    /**
+     * The old `KbqWarningTooltipTrigger` / `KbqExtendedTooltipTrigger` subclasses had
+     * setters on their content/header inputs that pushed updates into the open tooltip.
+     * Now that `modifier` and `header` are plain `@Input` fields on this base class,
+     * we need to mirror that reactivity manually — without it, changing the inputs
+     * while a tooltip is open silently leaves the overlay showing stale data until
+     * the next show/hide cycle.
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    show(delay?: number): void;
+    /** method allows to show the tooltip relative to the given mouse event. */
+    showForMouseEvent(event: MouseEvent): void;
+    /**
+     * method allows to show the tooltip relative to the element
+     * Use this approach when it is not possible to define a trigger in the template.
+     *
+     * For example:
+     * const tooltip = new KbqTooltipTrigger();
+     * tooltip.showForElement(element);
+     */
+    showForElement(element: HTMLElement): void;
+    updateData(): void;
+    closingActions(): rxjs.Observable<void | MouseEvent>;
+    getOverlayHandleComponentType(): Type<KbqTooltipComponent>;
+    updateClassMap(newPlacement?: string): void;
+    protected applyRelativeToPointer(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTooltipTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTooltipTrigger, "[kbqTooltip]", ["kbqTooltip"], { "forDisabledComponent": { "alias": "forDisabledComponent"; "required": false; "isSignal": true; }; "ignoreTooltipPointerEvents": { "alias": "ignoreTooltipPointerEvents"; "required": false; "isSignal": true; }; "hideWithTimeout": { "alias": "hideWithTimeout"; "required": false; }; "tooltipVisible": { "alias": "kbqVisible"; "required": false; }; "tooltipPlacement": { "alias": "kbqPlacement"; "required": false; }; "relativeToPointer": { "alias": "kbqRelativeToPointer"; "required": false; }; "tooltipPlacementPriority": { "alias": "kbqPlacementPriority"; "required": false; }; "content": { "alias": "kbqTooltip"; "required": false; }; "disabled": { "alias": "kbqTooltipDisabled"; "required": false; }; "enterDelay": { "alias": "kbqEnterDelay"; "required": false; }; "leaveDelay": { "alias": "kbqLeaveDelay"; "required": false; }; "trigger": { "alias": "kbqTrigger"; "required": false; }; "customClass": { "alias": "kbqTooltipClass"; "required": false; }; "context": { "alias": "kbqTooltipContext"; "required": false; }; "color": { "alias": "kbqTooltipColor"; "required": false; }; "arrow": { "alias": "kbqTooltipArrow"; "required": false; }; "offset": { "alias": "kbqTooltipOffset"; "required": false; }; "modifier": { "alias": "kbqTooltipModifier"; "required": false; }; "header": { "alias": "kbqTooltipHeader"; "required": false; }; }, { "placementChange": "kbqPlacementChange"; "visibleChange": "kbqVisibleChange"; }, never, never, true, never>;
+    static ngAcceptInputType_hideWithTimeout: unknown;
+    static ngAcceptInputType_relativeToPointer: unknown;
+    static ngAcceptInputType_arrow: unknown;
+    static ngAcceptInputType_offset: unknown;
+}
+
+declare class KbqToolTipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqToolTipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqToolTipModule, never, [typeof KbqTooltipComponent, typeof KbqTooltipTrigger], [typeof KbqTooltipComponent, typeof KbqTooltipTrigger]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqToolTipModule>;
+}
+
+export { KBQ_TOOLTIP_OPEN_TIME, KBQ_TOOLTIP_OPEN_TIME_PROVIDER, KBQ_TOOLTIP_SCROLL_STRATEGY, KBQ_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER, KbqToolTipModule, KbqTooltipComponent, KbqTooltipTrigger, MIN_TIME_FOR_DELAY, TooltipModifier, kbqTooltipScrollStrategyFactory };

package/top-bar/index.d.ts

@@ -1 +1,33 @@
-export * from './public-api';
+import * as i0 from '@angular/core';
+
+declare class KbqTopBarSpacer {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTopBarSpacer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTopBarSpacer, "[kbqTopBarSpacer]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive that dynamically applying CSS classes based on a placement value (left or right).
+ */
+declare class KbqTopBarContainer {
+    /**
+     * Conditionally applies a CSS class based on the value
+     */
+    readonly placement: i0.InputSignal<"start" | "end">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTopBarContainer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTopBarContainer, "[kbqTopBarContainer]", never, { "placement": { "alias": "placement"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class KbqTopBar {
+    /**
+     * Enables overflow behavior, applying `kbq-top-bar-overflow` to show a bottom shadow.
+     */
+    readonly withShadow: i0.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTopBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTopBar, "kbq-top-bar", never, { "withShadow": { "alias": "withShadow"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class KbqTopBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTopBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqTopBarModule, never, [typeof KbqTopBar, typeof KbqTopBarContainer, typeof KbqTopBarSpacer], [typeof KbqTopBar, typeof KbqTopBarContainer, typeof KbqTopBarSpacer]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqTopBarModule>;
+}
+
+export { KbqTopBar, KbqTopBarContainer, KbqTopBarModule, KbqTopBarSpacer };

package/tree/_tree-theme.scss

@@ -53,10 +53,14 @@
 
             &.kbq-checked:not(.kbq-selected),
             &.kbq-tree-option_multiple.kbq-selected {
+                --kbq-option-background: var(--kbq-tree-multiple-states-selected-container-background);
+
                 background: var(--kbq-tree-multiple-states-selected-container-background);
 
                 &:hover,
                 &.kbq-hovered {
+                    --kbq-option-background: var(--kbq-tree-multiple-states-selected-hover-container-background);
+
                     background: var(--kbq-tree-multiple-states-selected-hover-container-background);
                 }
             }