@koobiq/components 20.4.2 → 21.0.1

package/toast/index.d.ts

@@ -1,178 +0,0 @@
-import * as i0 from '@angular/core';
-import { InjectionToken, TemplateRef, 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>;
-    private readonly overlayKeyboardDispatcher;
-    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;
-    /**
-     * Re-applies the position of every overlay anchored to an element; one whose origin has not moved stays where it
-     * is. CDK keeps no public registry of attached overlays, but its keyboard dispatcher tracks each of them.
-     */
-    private repositionConnectedOverlays;
-    /**
-     * Fakes a scroll on the container so that overlays anchored inside a toast are repositioned by their
-     * `RepositionScrollStrategy` when the stack shifts.
-     *
-     * @deprecated The container repositions the overlays anchored inside it on its own, so nothing calls this.
-     * It is kept only for callers that already hold a container reference — the instance created by
-     * `KbqToastService` is not exposed. The fake scroll also closes every close-on-scroll overlay of the app.
-     */
-    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,104 +0,0 @@
-import * as _angular_core from '@angular/core';
-import { AfterViewInit, OnDestroy, ElementRef } from '@angular/core';
-import { ControlValueAccessor } from '@angular/forms';
-import * as i1 from '@koobiq/components/core';
-import { KbqColorDirective, TransitionCheckState, KbqCheckableClickAction, KbqCheckedState } from '@koobiq/components/core';
-import * as i1$1 from '@angular/cdk/a11y';
-
-type ToggleLabelPositionType = 'left' | 'right';
-declare class KbqToggleChange {
-    source: KbqToggleComponent;
-    checked: boolean;
-}
-/**
- * Toggle click action when user click on input element. Alias of `KbqCheckableClickAction`.
- */
-type KbqToggleClickAction = KbqCheckableClickAction;
-declare class KbqToggleComponent extends KbqColorDirective implements AfterViewInit, ControlValueAccessor, OnDestroy {
-    private readonly changeDetectorRef;
-    private readonly focusMonitor;
-    private readonly checkable;
-    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);
-    get tabIndex(): number;
-    set tabIndex(value: number);
-    get checked(): boolean;
-    set checked(value: boolean);
-    /**
-     * 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);
-    /**
-     * 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: KbqToggleClickAction;
-    private uniqueId;
-    constructor();
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-    focus(): void;
-    getAriaChecked(): KbqCheckedState;
-    onChangeEvent(event: Event): void;
-    onLabelTextChange(): void;
-    onInputClick(event: MouseEvent): void;
-    /**
-     * Implemented as part of ControlValueAccessor.
-     * @deprecated Unused - `ControlValueAccessor` is now implemented by the `KbqCheckable` host directive,
-     * so this is never called by Angular forms. Will be removed in the next major version.
-     */
-    writeValue(value: any): void;
-    /**
-     * Implemented as part of ControlValueAccessor.
-     * @deprecated Unused - `ControlValueAccessor` is now implemented by the `KbqCheckable` host directive,
-     * so this is never called by Angular forms. Will be removed in the next major version.
-     */
-    registerOnChange(fn: any): void;
-    /**
-     * Implemented as part of ControlValueAccessor.
-     * @deprecated Unused - `ControlValueAccessor` is now implemented by the `KbqCheckable` host directive,
-     * so this is never called by Angular forms. Will be removed in the next major version.
-     */
-    registerOnTouched(fn: any): void;
-    /**
-     * Implemented as part of ControlValueAccessor.
-     * @deprecated Unused - `ControlValueAccessor` is now implemented by the `KbqCheckable` host directive,
-     * so this is never called by Angular forms. Will be removed in the next major version.
-     */
-    setDisabledState(isDisabled: boolean): void;
-    private setTransitionCheckState;
-    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, [{ directive: typeof i1.KbqCheckable; inputs: {}; outputs: {}; }]>;
-    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$1.A11yModule, typeof KbqToggleComponent], [typeof KbqToggleComponent]>;
-    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqToggleModule>;
-}
-
-export { KbqToggleChange, KbqToggleComponent, KbqToggleModule };
-export type { KbqToggleClickAction };

package/tooltip/index.d.ts

@@ -1,335 +0,0 @@
-import * as i0 from '@angular/core';
-import { InjectionToken, ElementRef, AfterViewInit, OnChanges, OnDestroy, Renderer2, WritableSignal, TemplateRef, EventEmitter, SimpleChanges, Type } from '@angular/core';
-import * as rxjs from 'rxjs';
-import { FocusMonitor } from '@angular/cdk/a11y';
-import { ScrollStrategy, Overlay, OverlayConfig } from '@angular/cdk/overlay';
-import { KbqPopUp, KbqPopUpTrigger, KbqParentPopup, KbqPopUpPlacementValues, KbqComponentColors } from '@koobiq/components/core';
-
-/**
- * Default value of the `kbqTooltipSingleInstance` input. Provide `false` at the application level to
- * globally disable the "only one tooltip is visible at a time" behavior.
- */
-declare const KBQ_TOOLTIP_SINGLE_INSTANCE_DEFAULT: InjectionToken<boolean>;
-/**
- * Contract of a tooltip taking part in the "only one tooltip is visible at a time" group.
- * @docs-private
- */
-interface KbqExclusiveTooltip {
-    /** Hides the tooltip because another tooltip — or a pop-up on the same element — has taken its place. */
-    hideAsInactive(): void;
-}
-/**
- * Keeps track of the single tooltip that is currently visible, so that showing a new one hides the
- * previous. Holds the *trigger*, not the overlay component — the latter is re-created on every show.
- */
-declare class KbqTooltipRegistry {
-    /** Tooltip that currently owns the screen, or `null` when nothing is visible. */
-    private visibleTooltip;
-    /** Marks the tooltip as the only visible one, hiding the previously visible tooltip. */
-    setVisible(tooltip: KbqExclusiveTooltip): void;
-    /**
-     * Clears the registry, but only when the given tooltip is still the registered one. The guard
-     * matters because hiding the previous tooltip is asynchronous: its `visibleChange(false)` arrives
-     * after the new tooltip has already been registered, and must not wipe that newer entry.
-     */
-    clearVisible(tooltip: KbqExclusiveTooltip): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTooltipRegistry, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<KbqTooltipRegistry>;
-}
-
-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;
-};
-/**
- * Trigger directive that shows a `KbqTooltipComponent` for its host element. Extends `KbqPopUpTrigger` with
- * tooltip-specific inputs (content, placement, color, arrow, enter/leave delays, modifier and header) and
- * behavior such as opening on keyboard focus only and positioning relative to the mouse cursor.
- */
-declare class KbqTooltipTrigger extends KbqPopUpTrigger<KbqTooltipComponent> implements AfterViewInit, OnChanges, OnDestroy, KbqExclusiveTooltip {
-    /** Registry holding the single tooltip that is currently visible. */
-    private readonly tooltipRegistry;
-    private readonly injectedScrollStrategy;
-    /**
-     * Per-instance override for the scroll strategy, taking precedence over `KBQ_TOOLTIP_SCROLL_STRATEGY`
-     * when set. An `@Input` rather than a DI override so it applies to this tooltip instance only, without
-     * leaking into other `kbqTooltip`s nested inside the same host (DI overrides are visible to every
-     * descendant in the element-injector tree, not just the element they're declared on).
-     * @docs-private
-     */
-    readonly scrollStrategyOverride: i0.InputSignal<(() => ScrollStrategy) | undefined>;
-    /** @docs-private */
-    protected get scrollStrategy(): () => ScrollStrategy;
-    /** @docs-private */
-    protected parentPopup: KbqParentPopup | null;
-    /**
-     * Pop-ups anchored to the very same element — a popover, a dropdown, a select and so on. Resolved with
-     * `self` so a pop-up further up the tree (which the tooltip merely lives inside) is not picked up; that
-     * case is covered by `parentPopup`.
-     */
-    private readonly siblingPopups;
-    /** @docs-private */
-    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>;
-    /**
-     * Whether the tooltip takes part in the "only one tooltip is visible at a time" group: showing it
-     * hides the previously visible tooltip, and it is hidden when another tooltip is shown.
-     *
-     * Defaults to `true`; the default can be changed application-wide with the
-     * `KBQ_TOOLTIP_SINGLE_INSTANCE_DEFAULT` token.
-     *
-     * Tooltips without an interactive `kbqTrigger` (`manual`, `none`, …) never take part in the group,
-     * regardless of this input — they are shown imperatively and are expected to stay pinned.
-     */
-    readonly singleInstance: i0.InputSignalWithTransform<boolean, unknown>;
-    /**
-     * 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;
-    /** Input (`kbqVisible`) that programmatically shows or hides the tooltip; reflects the current `visible` state. */
-    get tooltipVisible(): boolean;
-    set tooltipVisible(value: boolean);
-    /** Input (`kbqPlacement`) that sets the tooltip placement relative to its trigger; reflects the current `placement`. */
-    get tooltipPlacement(): KbqPopUpPlacementValues;
-    set tooltipPlacement(value: KbqPopUpPlacementValues);
-    /**
-     * Positions the tooltip relative to the mouse cursor. Only available for top and bottom kbqPlacement.
-     * Does not work with kbqPlacementPriority.
-     */
-    relativeToPointer: boolean;
-    /** Input (`kbqPlacementPriority`) that sets the ordered fallback placements; reflects the current `placementPriority`. */
-    get tooltipPlacementPriority(): string | string[] | null;
-    set tooltipPlacementPriority(value: string | string[] | null);
-    /** Input (`kbqTooltip`) with the tooltip content — a string or a template. Updating it refreshes an open tooltip. */
-    get content(): string | TemplateRef<any>;
-    set content(content: string | TemplateRef<any>);
-    /** Input (`kbqTooltipDisabled`) controlling whether the tooltip is disabled; setting it to `true` hides it. */
-    get disabled(): boolean;
-    set disabled(value: boolean);
-    /** Input (`kbqEnterDelay`) — delay in milliseconds before the tooltip is shown. Defaults to `400`. */
-    enterDelay: number;
-    /** Input (`kbqLeaveDelay`) — delay in milliseconds before the tooltip is hidden. Defaults to `0`. */
-    leaveDelay: number;
-    /** Input (`kbqTrigger`) with the comma-separated trigger events. An empty value resets to hover + focus and rebinds listeners. */
-    get trigger(): string;
-    set trigger(value: string);
-    /** Backing field for `trigger`; defaults to hover + focus. */
-    protected _trigger: string;
-    /** Input (`kbqTooltipClass`) with an extra CSS class applied to the tooltip; updating it refreshes the class map. */
-    get customClass(): string;
-    set customClass(value: string);
-    /** Input (`kbqTooltipContext`) with the context object passed to a template tooltip; updating it refreshes the open tooltip. */
-    get context(): any;
-    set context(ctx: any);
-    /** Backing field for `context`. */
-    private _context;
-    /** Input (`kbqTooltipColor`) with the tooltip color theme; the getter returns the `kbq-`-prefixed CSS class. */
-    get color(): string;
-    set color(value: KbqComponentColors | string);
-    /** Backing field for `color`; defaults to `KbqComponentColors.Contrast`. */
-    private _color;
-    /** Input (`kbqTooltipArrow`) — whether to render the tooltip's arrow/pointer. Defaults to `false`. */
-    arrow: boolean;
-    /** Input (`kbqTooltipOffset`) — distance in pixels between the tooltip and its trigger; `null` uses the default. */
-    offset: number | null;
-    /** Output (`kbqPlacementChange`) that emits the new placement whenever the tooltip repositions. */
-    readonly placementChange: EventEmitter<any>;
-    /** Output (`kbqVisibleChange`) that emits when the tooltip's visibility changes. */
-    readonly visibleChange: EventEmitter<boolean>;
-    /** Whether the configured trigger list includes the `click` trigger. */
-    private get hasClickInTrigger();
-    /** @docs-private */
-    protected originSelector: string;
-    /** @docs-private */
-    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;
-    /**
-     * Whether this tooltip takes part in the "only one tooltip is visible at a time" group.
-     *
-     * Read through the `trigger` getter on purpose: `KbqTitleDirective` always reports `hover`, so title
-     * tooltips participate, while `kbqValidationTooltip` consumers (datepicker, timepicker, inline-edit)
-     * assign `trigger = 'manual'` and therefore stay out of the group.
-     */
-    private get participatesInSingleInstance();
-    /**
-     * Whether `kbqTrigger` contains at least one user-driven event, i.e. the tooltip is not driven purely
-     * imperatively. `manual`/`none` tooltips (the validation hints of datepicker, timepicker and inline-edit)
-     * bind no listeners and are expected to stay pinned while the user keeps interacting elsewhere.
-     */
-    private get hasInteractiveTrigger();
-    /**
-     * Whether the tooltip is muted because a pop-up on the same element has taken over the anchor.
-     *
-     * Set when that pop-up opens and released only once the pointer or the focus genuinely leaves the host,
-     * never on the pop-up closing. Both matter: a pop-up restores focus to its trigger when it closes (see
-     * `KbqPopoverComponent.onEscape`), and removing its backdrop replays `mouseenter` on the trigger without
-     * the pointer having moved — either would otherwise pop the tooltip up out of nowhere. A pointer that left
-     * the host while the pop-up was open (see `pointerLeftWhileMuted`) releases it by coming back once the
-     * pop-up is closed.
-     */
-    private mutedBySiblingPopup;
-    /**
-     * Whether the pointer left the host while muted. A backdrop inserted under the resting pointer fires
-     * `mouseleave` as well, but with the pointer still within the host — that one does not count.
-     */
-    private pointerLeftWhileMuted;
-    /**
-     * Sets up an effect that mirrors a `forDisabledComponent`'s disabled signal: when that component is disabled it
-     * makes the host focusable (so the tooltip can still be triggered) and enables the tooltip, otherwise disables it.
-     *
-     * Also joins the "only one tooltip is visible at a time" group and mutes the tooltip while a pop-up on the
-     * same element is open. All of this wiring lives here rather than in `ngAfterViewInit`/`ngOnDestroy` because
-     * several subclasses override those hooks: `KbqTitleDirective` and `KbqEllipsisCenterDirective` skip
-     * `super.ngAfterViewInit()`, and `KbqPasswordToggle` skips `super` in both hooks entirely. `destroyRef`
-     * additionally covers a trigger destroyed while its tooltip is still visible — that path disposes the
-     * overlay without emitting `visibleChange(false)`.
-     */
-    constructor();
-    /**
-     * Hides the tooltip when a parent pop-up closes, starts focus monitoring on the host, and—when
-     * `ignoreTooltipPointerEvents` is set—adds the panel class that makes the tooltip ignore pointer events.
-     */
-    ngAfterViewInit(): void;
-    /** Stops focus monitoring on the host element and runs the base-class teardown. */
-    ngOnDestroy(): void;
-    /**
-     * Shows the tooltip after `delay` ms. Suppresses showing while a pop-up on the same element holds the
-     * anchor or on a focus trigger that did not originate from the keyboard, and applies cursor-relative
-     * positioning when `relativeToPointer` is enabled.
-     */
-    show(delay?: number): void;
-    /**
-     * Hides the tooltip after `delay` ms and, when the user has genuinely left the host, un-mutes a tooltip
-     * that a pop-up on the same element had muted.
-     *
-     * `mouseleave` and `blur` are the release signals because the base class binds `hide` to both regardless
-     * of whether the tooltip is currently visible. A pop-up that is still attached does not count: its
-     * backdrop steals the hover from the trigger while the pointer stands still, and that `mouseleave` must
-     * not be mistaken for the user leaving.
-     */
-    hide(delay?: number): void;
-    /**
-     * Records whether the pointer left the host while muted, see `pointerLeftWhileMuted`.
-     * @docs-private
-     */
-    protected trackPointerLeave(event: MouseEvent): void;
-    /**
-     * Hides the tooltip because something else took its place — another tooltip became visible, or a pop-up
-     * anchored to the same element opened.
-     *
-     * Goes straight to the pop-up instead of `hide()`: `hide()` silently no-ops when the last recorded
-     * `triggerName` is `mouseleave` and the pop-up itself is hovered. Hiding through the instance keeps
-     * `visibleChange(false)` firing, so `isOpen`, `kbqVisibleChange` and the `kbqVisible` input stay in sync.
-     * Does nothing when the tooltip is already detached or when closing is prevented.
-     * @docs-private */
-    hideAsInactive(): void;
-    /** method allows to show the tooltip relative to the given mouse event.
-     * @docs-private */
-    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);
-     * @docs-private */
-    showForElement(element: HTMLElement): void;
-    /** @docs-private */
-    updateData(): void;
-    /** @docs-private */
-    closingActions(): rxjs.Observable<void | MouseEvent>;
-    /** @docs-private */
-    getOverlayHandleComponentType(): Type<KbqTooltipComponent>;
-    /** @docs-private */
-    updateClassMap(newPlacement?: string): void;
-    /** @docs-private */
-    protected applyRelativeToPointer(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTooltipTrigger, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTooltipTrigger, "[kbqTooltip]", ["kbqTooltip"], { "scrollStrategyOverride": { "alias": "kbqTooltipScrollStrategy"; "required": false; "isSignal": true; }; "forDisabledComponent": { "alias": "forDisabledComponent"; "required": false; "isSignal": true; }; "ignoreTooltipPointerEvents": { "alias": "ignoreTooltipPointerEvents"; "required": false; "isSignal": true; }; "singleInstance": { "alias": "kbqTooltipSingleInstance"; "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, KBQ_TOOLTIP_SINGLE_INSTANCE_DEFAULT, KbqToolTipModule, KbqTooltipComponent, KbqTooltipRegistry, KbqTooltipTrigger, MIN_TIME_FOR_DELAY, TooltipModifier, kbqTooltipScrollStrategyFactory };
-export type { KbqExclusiveTooltip };

package/top-bar/index.d.ts

@@ -1,33 +0,0 @@
-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 };