@koobiq/components 20.4.1 → 21.0.0

package/types/koobiq-components-tooltip.d.ts

@@ -0,0 +1,610 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, ElementRef, AfterViewInit, OnChanges, OnDestroy, InputSignal, Renderer2, WritableSignal, TemplateRef, EventEmitter, SimpleChanges, Type } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { FocusMonitor, FocusOrigin } from '@angular/cdk/a11y';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ScrollStrategy, Overlay, OverlayConfig, OverlayRef } from '@angular/cdk/overlay';
+import { KbqPopUp, KbqEnumValues, 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>;
+}
+
+/**
+ * What the tooltip is vertically anchored to when it is positioned relative to the caret:
+ *
+ * - `'line'` — the line of text the caret is on.
+ * - `'field'` — the whole field, so the tooltip never covers it; horizontally it still follows the caret.
+ * - `'auto'` — `'field'` for a single-line `<input>`, `'line'` for everything else.
+ */
+type KbqCaretVerticalAnchor = 'auto' | 'line' | 'field';
+declare enum TooltipModifier {
+    Default = "default",
+    Warning = "warning",
+    Extended = "extended"
+}
+/**
+ * @deprecated Replaced by {@link KbqTooltipDelayTracker}, which owns the shared timestamp behind a service
+ * instead of a mutable `useValue` object. The tooltip no longer reads this token; providing it has no effect. Will be
+ * removed in 22.0.0.
+ */
+declare const KBQ_TOOLTIP_OPEN_TIME: InjectionToken<{
+    value: number;
+}>;
+/**
+ * @deprecated Replaced by {@link KbqTooltipDelayTracker}. Providing it has no effect. Will be removed in 22.0.0.
+ *
+ * @docs-private
+ */
+declare const KBQ_TOOLTIP_OPEN_TIME_PROVIDER: {
+    provide: InjectionToken<{
+        value: number;
+    }>;
+    useValue: {
+        value: number;
+    };
+};
+/** Default length of the window during which a following tooltip is shown without its enter delay. */
+declare const MIN_TIME_FOR_DELAY = 2000;
+/**
+ * Length in milliseconds of the window during which a tooltip shown right after another one appears
+ * instantly. Defaults to {@link MIN_TIME_FOR_DELAY}.
+ */
+declare const KBQ_TOOLTIP_INSTANT_SHOW_WINDOW: InjectionToken<number>;
+/**
+ * Remembers when a tooltip was last shown, so that moving between neighbouring triggers does not replay the
+ * enter delay for every one of them: the first tooltip waits `kbqEnterDelay`, the ones following it within
+ * {@link KBQ_TOOLTIP_INSTANT_SHOW_WINDOW} appear instantly.
+ *
+ * Application-wide by design — the behavior is part of the component's documented delay rules.
+ */
+declare class KbqTooltipDelayTracker {
+    private readonly instantShowWindow;
+    /** Timestamp of the last shown tooltip, or `null` while no tooltip has been shown recently. */
+    private lastShownAt;
+    /** Whether the tooltip that is about to be shown should skip its enter delay. */
+    shouldSkipEnterDelay(): boolean;
+    /** Records that a tooltip has just been shown. */
+    markShown(): void;
+    /** Forgets the last shown tooltip, so the next one appears with its full enter delay. */
+    reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTooltipDelayTracker, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KbqTooltipDelayTracker>;
+}
+declare class KbqTooltipComponent extends KbqPopUp {
+    private readonly delayTracker;
+    prefix: string;
+    /**
+     * Id rendered on the tooltip element; the trigger points its `aria-describedby` at it.
+     *
+     * Public only because the trigger is a separate class and overwrites it with its own id — nothing outside
+     * the pair should read or write it, or the accessibility link between them breaks.
+     *
+     * @docs-private
+     */
+    id: string;
+    private readonly tooltipElement;
+    /** The tooltip panel, which the base pop-up measures and decorates instead of the host. */
+    get elementRef(): ElementRef<HTMLElement>;
+    show(delay: number): void;
+    /**
+     * Applies `offset` as the gap between the tooltip and its trigger. Called both on show and whenever the
+     * trigger pushes new data, so that changing `kbqTooltipOffset` on an open tooltip actually moves it.
+     *
+     * Public only because the trigger calls it from the outside; it is not part of the supported surface.
+     *
+     * @docs-private
+     */
+    applyOffset(): void;
+    updateClassMap(placement: string, customClass: string, { modifier }: {
+        modifier: KbqEnumValues<TooltipModifier>;
+    }): 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;
+/**
+ * Redundant to the root factory of the token; kept so an app can restore the default under its own override (#DS-2196).
+ *
+ * @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: InputSignal<(() => ScrollStrategy) | undefined>;
+    /** Id of the tooltip element this trigger points its `aria-describedby` at while the tooltip is open. */
+    private readonly tooltipId;
+    /** @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: InputSignal<Record<"disabledSignal", WritableSignal<boolean>> | undefined>;
+    /**
+     * Determines whether pointer events should be ignored on tooltips.
+     *
+     * When set to `true`, the tooltip pane does not receive pointer events, so clicks and hovers pass through
+     * to whatever is underneath it. Defaults to `false`, which keeps the tooltip hoverable: a user who needs
+     * more time to read it — or who reads at high magnification, where the pointer often ends up over the
+     * tooltip itself — can move the pointer onto it without it disappearing (WCAG 1.4.13 "Content on Hover").
+     *
+     * Set it to `true` for tooltips that float over other click targets, such as the overflow hints of a
+     * scrolling option list.
+     */
+    readonly ignoreTooltipPointerEvents: 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;
+    /**
+     * Positions the tooltip relative to the text caret of the field it is attached to, following it while the
+     * user types, moves the caret and scrolls the field. Anchors to the selection whenever there is one.
+     *
+     * Every placement is available, unlike with `kbqRelativeToPointer`: the caret is anchored as a rectangle,
+     * so the usual fallback placements keep the tooltip on screen. Wins when both inputs are enabled.
+     *
+     * The field is the host element itself when it is editable, otherwise the first editable it wraps.
+     */
+    relativeToCaret: boolean;
+    /** What the tooltip is vertically anchored to while `kbqRelativeToCaret` is enabled. */
+    relativeToCaretVertical: KbqCaretVerticalAnchor;
+    /** 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<unknown>;
+    set content(content: string | TemplateRef<unknown>);
+    /**
+     * Input (`kbqTooltipDisabled`) controlling whether the tooltip is disabled; setting it to `true` hides it.
+     * `undefined` leaves the decision to the trigger, like an unset input.
+     *
+     * Reads back the *effective* state, which for triggers that derive one of their own (see
+     * `derivedDisabledWins`) is not necessarily the value that was written.
+     */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    /**
+     * Whether the state this trigger derives means *there is nothing to show*, so an explicit
+     * `kbqTooltipDisabled="false"` cannot override it, as for a hint that repeats text the host never clipped.
+     * Otherwise the explicit value wins in both directions, so `false` on a wrapped control that is not disabled
+     * still asks for a tooltip.
+     *
+     * @docs-private
+     */
+    protected readonly derivedDisabledWins: boolean;
+    private explicitlyDisabled;
+    private derivedDisabled;
+    /** 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(): unknown;
+    set context(ctx: unknown);
+    /** Backing field for `context`. */
+    private _context;
+    /** Input (`kbqTooltipColor`) with the tooltip color theme. Defaults to `KbqComponentColors.Contrast`. */
+    get color(): KbqComponentColors | string;
+    set color(value: KbqComponentColors | string);
+    /** CSS class the current `color` maps to. */
+    protected get colorClass(): 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`, the default, keeps
+     * the gap of the stylesheet.
+     */
+    offset: number | null;
+    /** Output (`kbqPlacementChange`) that emits the new placement whenever the tooltip repositions. */
+    readonly placementChange: EventEmitter<"top" | "topLeft" | "topRight" | "right" | "rightTop" | "rightBottom" | "left" | "leftTop" | "leftBottom" | "bottom" | "bottomLeft" | "bottomRight">;
+    /** @docs-private */
+    readonly placementChangeOutput: i0.OutputRef<"top" | "topLeft" | "topRight" | "right" | "rightTop" | "rightBottom" | "left" | "leftTop" | "leftBottom" | "bottom" | "bottomLeft" | "bottomRight">;
+    /** Output (`kbqVisibleChange`) that emits when the tooltip's visibility changes. */
+    readonly visibleChange: EventEmitter<boolean>;
+    /** @docs-private */
+    readonly visibleChangeOutput: i0.OutputRef<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: KbqEnumValues<TooltipModifier>;
+    /**
+     * Header text or template, rendered above the tooltip content. Only meaningful with
+     * `kbqTooltipModifier="extended"`. Replaces the removed `KbqExtendedTooltipTrigger.header`.
+     */
+    header: string | TemplateRef<unknown>;
+    /**
+     * Hands each bound input to its member, and pushes a later change of `modifier`, `header`, `arrow` or
+     * `offset` — plain fields — into an open tooltip, which would otherwise show 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;
+    /**
+     * Origin of the last focus event on the host, cached from the `FocusMonitor` stream so the focus trigger
+     * can tell a keyboard focus from the one a click leaves behind.
+     */
+    protected lastFocusOrigin: FocusOrigin;
+    /** @docs-private */
+    readonly triggerInput: InputSignal<string | undefined>;
+    /** @docs-private */
+    readonly hideWithTimeoutInput: i0.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly enterDelayInput: InputSignal<number | undefined>;
+    /** @docs-private */
+    readonly leaveDelayInput: InputSignal<number | undefined>;
+    /** @docs-private */
+    readonly relativeToPointerInput: i0.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly relativeToCaretInput: i0.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly relativeToCaretVerticalInput: InputSignal<KbqCaretVerticalAnchor | undefined>;
+    /** @docs-private */
+    readonly contentInput: InputSignal<KbqTooltipTrigger['content'] | undefined>;
+    /** @docs-private */
+    readonly headerInput: InputSignal<KbqTooltipTrigger['header'] | undefined>;
+    /** @docs-private */
+    readonly modifierInput: InputSignal<"default" | "warning" | "extended" | undefined>;
+    /** @docs-private */
+    readonly contextInput: InputSignal<{} | null | undefined>;
+    /** @docs-private */
+    readonly customClassInput: InputSignal<string | undefined>;
+    /** @docs-private */
+    readonly colorInput: InputSignal<string | undefined>;
+    /** @docs-private */
+    readonly arrowInput: i0.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly offsetInput: i0.InputSignalWithTransform<number | undefined, string | number | null | undefined>;
+    /** @docs-private */
+    readonly disabledInput: i0.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly tooltipPlacementPriorityInput: InputSignal<string | string[] | null | undefined>;
+    /** @docs-private */
+    readonly tooltipPlacementInput: InputSignal<"top" | "topLeft" | "topRight" | "right" | "rightTop" | "rightBottom" | "left" | "leftTop" | "leftBottom" | "bottom" | "bottomLeft" | "bottomRight" | undefined>;
+    /** @docs-private */
+    readonly tooltipVisibleInput: InputSignal<boolean | undefined>;
+    /**
+     * 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, mutes the tooltip while a pop-up on the
+     * same element is open, tracks the focus origin and keeps the trigger's `aria-describedby` in sync with the
+     * open tooltip. 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. */
+    ngAfterViewInit(): void;
+    /** Stops focus monitoring on the host element and runs the base-class teardown. */
+    ngOnDestroy(): void;
+    /**
+     * Records the state the subclass derived from its own content and re-folds it with the consumer's
+     * `kbqTooltipDisabled`. Subclasses call this instead of writing `disabled`, which would be read back as
+     * the consumer's own value and lose whichever of the two was written first.
+     *
+     * @docs-private
+     */
+    protected setDerivedDisabled(value: boolean): void;
+    private foldDisabled;
+    /** Recomputes the effective `disabled` and closes an open tooltip that just lost its reason to be open. */
+    private applyDisabled;
+    /**
+     * 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;
+    /**
+     * Whether a pop-up on the same element is attached. Untracked: the siblings keep it in signals, and a consumer
+     * `effect()` that shows or hides the tooltip must not run again whenever one of them opens or closes.
+     */
+    private get siblingPopupAttached();
+    /**
+     * 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;
+    /**
+     * Shows the tooltip next to the cursor position of the given mouse event, anchoring it to the event's
+     * `currentTarget` instead of the directive's own host element.
+     *
+     * Use it when the trigger cannot be declared in the template — for instance for a tooltip shared by the
+     * cells of a virtualized table. The directive still has to be created in an injection context.
+     */
+    showForMouseEvent(event: MouseEvent): void;
+    /**
+     * Shows the tooltip anchored to the given element instead of the directive's own host element.
+     *
+     * Use it when the trigger cannot be declared in the template. The directive still has to be created in an
+     * injection context:
+     *
+     * ```ts
+     * const tooltip = runInInjectionContext(injector, () => new KbqTooltipTrigger());
+     * tooltip.showForElement(element);
+     * ```
+     *
+     * Does nothing while the tooltip is disabled or has no content — there is no overlay to anchor then.
+     */
+    showForElement(element: HTMLElement): void;
+    /**
+     * Replaces the CSS classes put on the tooltip's overlay pane.
+     *
+     * Exists for components that own a tooltip through `hostDirectives` instead of extending this class and
+     * therefore cannot reach the protected overlay configuration (e.g. `KbqNavbarItem`).
+     *
+     * @docs-private
+     */
+    setOverlayPanelClass(panelClass: string | string[]): void;
+    /** @docs-private */
+    updateData(): void;
+    /** @docs-private */
+    closingActions(): rxjs.Observable<void | MouseEvent>;
+    /** @docs-private */
+    getOverlayHandleComponentType(): Type<KbqTooltipComponent>;
+    /** @docs-private */
+    updateClassMap(newPlacement?: string): void;
+    /**
+     * Arms the `Escape` listener for as long as the tooltip overlay is attached, so that `Escape` dismisses
+     * the tooltip.
+     *
+     * The inherited `keydownHandler` is a host binding on the trigger and therefore only fires while the
+     * trigger itself has focus, which a hover-opened tooltip never has.
+     *
+     * @docs-private
+     */
+    createOverlay(): OverlayRef;
+    /** Teardown of the document-level `Escape` listener, or `null` while the overlay is detached. */
+    private unbindEscapeListener;
+    /**
+     * Binds a document-level `Escape` listener, outside the zone and at most once per attach.
+     *
+     * An open tooltip is the topmost layer, so `Escape` dismisses it first (WAI-ARIA tooltip pattern, WCAG 1.4.13):
+     * the listener captures the key and marks it spent, and a modal or a panel that closes on `Escape` lets it
+     * pass. The key is not stopped, so a control that closes a popup of its own on it still does.
+     *
+     * Deliberately not `overlayRef.keydownEvents()`: CDK hands each key to the last attached overlay that has
+     * subscribers and stops there, without re-dispatching. A tooltip is by construction the last overlay
+     * attached, so subscribing would make it swallow `Escape` for the modal, sidepanel, dropdown or inline
+     * edit underneath it — including for the imperative tooltips that drop the key instead of acting on it.
+     */
+    private listenForEscape;
+    /** Removes the document-level `Escape` listener. */
+    private stopListeningForEscape;
+    /** Panel classes of the tooltip overlay, including the pointer-events opt-out while it is enabled. */
+    private getPanelClasses;
+    /**
+     * Points the trigger's `aria-describedby` at the open tooltip, so assistive technology announces the hint
+     * together with the control it explains.
+     *
+     * Written through the renderer rather than a host binding because `showForMouseEvent` re-anchors the
+     * trigger to a foreign element, which a host binding would never reach. Existing ids are preserved.
+     */
+    private describeTrigger;
+    /** Removes this tooltip's id from the described element's `aria-describedby`, keeping any other ids. */
+    private undescribeTrigger;
+    /** Element whose `aria-describedby` points at this tooltip, or `null` while nothing is described. */
+    private describedElement;
+    /** Ids currently listed in the element's `aria-describedby`. */
+    private getDescribedByIds;
+    /**
+     * Whether the tooltip only repeats the text the host already shows — which is what `kbq-title` does.
+     * Describing those would make assistive technology read the same label twice.
+     */
+    private get describesHostText();
+    /** Teardown of the listeners following the caret, or `null` while the tooltip is not tracking one. */
+    private stopCaretListeners;
+    /**
+     * Field whose caret the tooltip is anchored to: the host element when it is editable itself — which is
+     * how the validation hints are written — otherwise the first editable element it wraps.
+     */
+    private getCaretAnchor;
+    /**
+     * Origin that stays on the caret of the field while `kbqRelativeToCaret` is enabled, and on the host element
+     * otherwise — so switching the input off while the tooltip is open does not leave it on the caret.
+     */
+    private readonly caretOrigin;
+    /**
+     * Anchors the overlay to the caret of the field.
+     *
+     * @docs-private
+     */
+    protected applyRelativeToCaret(): void;
+    /** @docs-private */
+    protected getAnchorSize(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Rectangle the tooltip is anchored to: the caret or selection of the field — spanning the whole field
+     * vertically when it anchors to the field — or the host element's box when the caret cannot be located or
+     * `kbqRelativeToCaret` is off.
+     */
+    private measureCaretAnchor;
+    /** Whether the tooltip takes its vertical position from the whole field rather than the caret's line. */
+    private anchorsToField;
+    /** Follows the caret for as long as the overlay is attached, outside the zone and at most once per attach. */
+    private startTrackingCaret;
+    private stopTrackingCaret;
+    /**
+     * Picks the placement again for where the caret is now. The position strategy is locked so that an element-anchored
+     * pop-up does not jump when its content changes, and a locked strategy only re-applies the placement chosen on
+     * opening; a caret walking to the edge of the screen has to be free to flip the tooltip, so the lock is lifted for
+     * this pass.
+     */
+    private repositionAtCaret;
+    /** @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; }; "triggerInput": { "alias": "kbqTrigger"; "required": false; "isSignal": true; }; "hideWithTimeoutInput": { "alias": "hideWithTimeout"; "required": false; "isSignal": true; }; "enterDelayInput": { "alias": "kbqEnterDelay"; "required": false; "isSignal": true; }; "leaveDelayInput": { "alias": "kbqLeaveDelay"; "required": false; "isSignal": true; }; "relativeToPointerInput": { "alias": "kbqRelativeToPointer"; "required": false; "isSignal": true; }; "relativeToCaretInput": { "alias": "kbqRelativeToCaret"; "required": false; "isSignal": true; }; "relativeToCaretVerticalInput": { "alias": "kbqRelativeToCaretVertical"; "required": false; "isSignal": true; }; "contentInput": { "alias": "kbqTooltip"; "required": false; "isSignal": true; }; "headerInput": { "alias": "kbqTooltipHeader"; "required": false; "isSignal": true; }; "modifierInput": { "alias": "kbqTooltipModifier"; "required": false; "isSignal": true; }; "contextInput": { "alias": "kbqTooltipContext"; "required": false; "isSignal": true; }; "customClassInput": { "alias": "kbqTooltipClass"; "required": false; "isSignal": true; }; "colorInput": { "alias": "kbqTooltipColor"; "required": false; "isSignal": true; }; "arrowInput": { "alias": "kbqTooltipArrow"; "required": false; "isSignal": true; }; "offsetInput": { "alias": "kbqTooltipOffset"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "kbqTooltipDisabled"; "required": false; "isSignal": true; }; "tooltipPlacementPriorityInput": { "alias": "kbqPlacementPriority"; "required": false; "isSignal": true; }; "tooltipPlacementInput": { "alias": "kbqPlacement"; "required": false; "isSignal": true; }; "tooltipVisibleInput": { "alias": "kbqVisible"; "required": false; "isSignal": true; }; }, { "placementChangeOutput": "kbqPlacementChange"; "visibleChangeOutput": "kbqVisibleChange"; }, never, never, true, never>;
+}
+
+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_INSTANT_SHOW_WINDOW, 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, KbqTooltipDelayTracker, KbqTooltipRegistry, KbqTooltipTrigger, MIN_TIME_FOR_DELAY, TooltipModifier, kbqTooltipScrollStrategyFactory };
+export type { KbqCaretVerticalAnchor, KbqExclusiveTooltip };