import * as _angular_core from '@angular/core';
import { InjectionToken, Signal, Provider } from '@angular/core';
import * as forty_cdk_tooltip from 'forty-cdk/tooltip';
import { VetoableNativeEvent } from 'forty-cdk/core';
import { AnchoredPositioningContext, Point, AnchoredOverlayPositioningBase, AnchoredPositioningSeedDefaults, FloatingSide, FloatingAlign } from 'forty-cdk/core-overlay';

/** Reason a show / hide was scheduled — `escape` and `press` bypass the close delay. */
type TooltipScheduleReason = 'hover' | 'focus' | 'escape' | 'press';
/**
 * Coordination contract owned by `ForTooltip`. Trigger and content register
 * their host elements so floating-ui can compute position; the optional arrow
 * registers itself so the `arrow` middleware can offset it inside the bubble.
 *
 * The trigger and content forward their host hover / focus events through the
 * `pointerEnter*` / `pointerLeave*` / `focusTrigger` / `blurTrigger` methods;
 * the root owns the single open / close decision so all keep-alive sources
 * (trigger hover, trigger focus, and — under `hoverableContent` — content
 * hover) are reconciled in one place.
 */
interface ForTooltipContext extends AnchoredPositioningContext {
    readonly open: Signal<boolean>;
    readonly disabled: Signal<boolean>;
    /** Whether the pointer may move into the content without dismissing the tooltip. */
    readonly hoverableContent: Signal<boolean>;
    /** Whether `prefers-reduced-motion: reduce` is active — reflected as `data-reduced-motion`. */
    readonly reducedMotion: Signal<boolean>;
    /** Trigger element id — a consumer-set host `id` is adopted, else a generated one. */
    readonly triggerId: Signal<string>;
    /** Content element id — a consumer-set host `id` is adopted, else a generated one. Referenced by the trigger's `aria-describedby` while open. */
    readonly contentId: Signal<string>;
    readonly trigger: Signal<HTMLElement | null>;
    registerTrigger(el: HTMLElement): void;
    unregisterTrigger(el: HTMLElement): void;
    /** Registers the content host element so the hoverable-content grace polygon can measure it. */
    registerContent(el: HTMLElement): void;
    unregisterContent(el: HTMLElement): void;
    /** Adopts a consumer-set static `id` on the content host into `contentId`. */
    adoptContentId(el: HTMLElement): void;
    registerArrow(el: HTMLElement): void;
    unregisterArrow(el: HTMLElement): void;
    /** The pointer entered the trigger; opens after the resolved open delay (gated by `showOnOverflow`). */
    pointerEnterTrigger(): void;
    /** The pointer left the trigger; closes, or arms the hoverable-content bridge from `cursor`. */
    pointerLeaveTrigger(cursor: Point): void;
    /** The trigger received focus; opens after the resolved open delay (gated by `showOnOverflow`). */
    focusTrigger(): void;
    /** The trigger lost focus; closes when nothing else keeps the tooltip alive. */
    blurTrigger(): void;
    /** The pointer entered the content (`hoverableContent`); holds the tooltip open. */
    pointerEnterContent(): void;
    /** The pointer left the content (`hoverableContent`); closes when nothing else keeps it alive. */
    pointerLeaveContent(): void;
    /**
     * Schedule the tooltip to open after `openDelay` ms (instant when delay is 0).
     * Hover-driven opens are suppressed while an ancestor scroll container is
     * moving content under a stationary cursor, so a row sliding past the pointer
     * can't flicker a tooltip open; the `'focus'` path is never suppressed.
     */
    scheduleOpen(reason: TooltipScheduleReason): void;
    /** Schedule the tooltip to close after `closeDelay` ms (instant on `escape` and `press`). */
    scheduleClose(reason: TooltipScheduleReason): void;
    /** Cancel any pending open/close timer without changing state. */
    cancelPending(): void;
    /**
     * Emit the public `(escapeKeyDown)` output and, unless prevented, close.
     * Driven by the content's document-level dismissible layer, so the tooltip
     * responds to Escape regardless of where focus lives — including a
     * hover-opened tooltip while focus sits on an unrelated element (WCAG 2.1 SC
     * 1.4.13) — and dismisses topmost-first when layered over a dialog.
     */
    emitEscapeKeyDown(event: KeyboardEvent): void;
}
declare const FOR_TOOLTIP_CONTEXT: InjectionToken<ForTooltipContext>;

/**
 * Headless implementation of the [WAI-ARIA Tooltip pattern](https://www.w3.org/WAI/ARIA/apg/patterns/tooltip/).
 *
 * Wrapper directive that owns open / closed state, hover / focus delays, and
 * placement. Provides the shared context to `ForTooltipTrigger`,
 * `ForTooltipContent`, and the optional `ForTooltipArrow`.
 *
 * Tooltip content is portaled to `document.body` and positioned via
 * `@floating-ui/dom`. Per APG, content must NOT be interactive — for
 * interactive popups use a Popover primitive.
 */
declare class ForTooltip extends AnchoredOverlayPositioningBase implements ForTooltipContext {
    #private;
    protected readonly positioningDefaults: forty_cdk_tooltip.ForTooltipDefaults;
    /**
     * Two-way bindable. Whether the tooltip is currently shown. The `model()`
     * change emitter (`(openChange)`) fires only on internal transitions
     * (hover/focus delays, Escape, and the force-close that runs when `disabled`
     * flips to true), never on consumer writes through `[(open)]` — observe
     * state changes without binding back.
     */
    readonly open: _angular_core.ModelSignal<boolean>;
    /**
     * Padding (px) keeping `[forTooltipArrow]` that far from the edges of the
     * content. Only consulted when an arrow is registered, since floating-ui
     * installs the `arrow` middleware only then — which is why the input is
     * declared here rather than on the shared positioning base. The default is
     * read from `provideForTooltipDefaults` for the surrounding scope, since arrow
     * geometry is a design-system-wide decision rather than a per-tooltip one.
     */
    readonly arrowPadding: _angular_core.InputSignalWithTransform<number, unknown>;
    /**
     * Per-tooltip override for the open delay (ms). When `undefined`
     * (default), falls back to `ForTooltipDefaults.openDelay` from the
     * surrounding `provideForTooltipDefaults` scope (700ms unless configured).
     */
    readonly openDelay: _angular_core.InputSignal<number | undefined>;
    /**
     * Per-tooltip override for the close delay (ms) after hover or focus
     * leaves. `Escape` ignores this. When `undefined` (default), falls back to
     * `ForTooltipDefaults.closeDelay` from the surrounding
     * `provideForTooltipDefaults` scope (300ms unless configured).
     */
    readonly closeDelay: _angular_core.InputSignal<number | undefined>;
    /** When true, all hover / focus interaction is ignored and any open tooltip is forced closed. */
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Per-tooltip override for whether the tooltip shows only when the
     * trigger's own text is truncated (`scrollWidth > clientWidth`) — the
     * common pattern for ellipsized labels where the tooltip adds nothing once
     * the full text is visible. When `undefined` (default), falls back to
     * `ForTooltipDefaults.showOnOverflow` from the surrounding
     * `provideForTooltipDefaults` scope (`false` unless configured).
     *
     * The input is aliased to `showOnOverflow`; consumers bind
     * `[showOnOverflow]="..."` (or the bare attribute) and read the effective
     * value via the public `showOnOverflow` computed below.
     */
    readonly _showOnOverflowInput: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
    /** Effective overflow gate: the `showOnOverflow` input when set, else the scope default. */
    readonly showOnOverflow: _angular_core.Signal<boolean>;
    /**
     * Per-tooltip override for whether the pointer may move into the content
     * without dismissing the tooltip. When `true`, the content drops its
     * default `pointer-events: none` while open and a pointer-grace "safe
     * triangle" bridges the gap between trigger and content so a slow diagonal
     * traversal doesn't close it. When `undefined` (default), falls back to
     * `ForTooltipDefaults.hoverableContent` from the surrounding
     * `provideForTooltipDefaults` scope (`true` unless configured).
     *
     * Per APG the content must stay non-interactive; this only allows the
     * pointer to rest over descriptive text (e.g. to select it).
     *
     * The input is aliased to `hoverableContent`; consumers bind
     * `[hoverableContent]="..."` (or the bare attribute) and read the effective
     * value via the public `hoverableContent` computed below.
     */
    readonly _hoverableContentInput: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
    /** Effective hoverable-content flag: the `hoverableContent` input when set, else the scope default. */
    readonly hoverableContent: _angular_core.Signal<boolean>;
    /**
     * Fires when the user presses Escape while the tooltip is open, regardless of
     * where focus currently lives — on the trigger or on an unrelated element (the
     * common case for a hover-opened tooltip). Routed through the content's
     * document-level dismissible layer. Call `preventDefault()` on the emitted
     * veto to keep the tooltip open. The native `KeyboardEvent` is on `.event`.
     */
    readonly escapeKeyDown: _angular_core.OutputEmitterRef<VetoableNativeEvent<KeyboardEvent>>;
    /**
     * Whether the user has requested reduced motion via the OS
     * `prefers-reduced-motion: reduce` media query. Reflected as the boolean
     * `data-reduced-motion` attribute on the root and content so consumers can
     * disable their own `animate.enter` / `animate.leave` and CSS transitions
     * without re-deriving the media query. Tooltip's JS-coordinated timing (the
     * open / close hover-intent delays) is intent debouncing, not motion, so it
     * is unchanged under reduced motion.
     */
    readonly reducedMotion: _angular_core.Signal<boolean>;
    /**
     * Id of the trigger element. A consumer-set `id` on the trigger host is
     * adopted at registration and preserved; the generated
     * `for-tooltip-trigger-*` id is only assigned when the host has none.
     */
    readonly triggerId: _angular_core.WritableSignal<string>;
    /** Generated id of the content element, wired to the trigger's `aria-describedby` while open. */
    readonly contentId: _angular_core.WritableSignal<string>;
    readonly trigger: _angular_core.Signal<HTMLElement | null>;
    readonly arrow: _angular_core.Signal<HTMLElement | null>;
    constructor();
    /**
     * Registers the trigger host element. Adopts a pre-existing consumer-set
     * `id` as the trigger id so external references (anchors, `aria-labelledby`,
     * label `for`) keep resolving; falls back to the generated id otherwise.
     */
    registerTrigger(el: HTMLElement): void;
    unregisterTrigger(el: HTMLElement): void;
    /** Registers the content host element so the hoverable-content grace polygon can measure it. */
    registerContent(el: HTMLElement): void;
    unregisterContent(el: HTMLElement): void;
    /** Adopts a consumer-set static `id` on the content host into `contentId`. */
    adoptContentId(el: HTMLElement): void;
    registerArrow(el: HTMLElement): void;
    unregisterArrow(el: HTMLElement): void;
    pointerEnterTrigger(): void;
    pointerLeaveTrigger(cursor: Point): void;
    focusTrigger(): void;
    blurTrigger(): void;
    pointerEnterContent(): void;
    pointerLeaveContent(): void;
    scheduleOpen(reason: TooltipScheduleReason): void;
    scheduleClose(reason: TooltipScheduleReason): void;
    cancelPending(): void;
    /**
     * Emit the public `(escapeKeyDown)` output and, unless the consumer calls
     * `preventDefault()` on the veto, close the tooltip immediately. Driven by the
     * content's document-level dismissible layer so Escape dismisses the tooltip
     * regardless of where focus currently lives — including a hover-opened tooltip
     * with focus on an unrelated element (WCAG 2.1 SC 1.4.13) — and so a tooltip
     * layered over a dialog is dismissed by the first Escape while the dialog
     * stays open (topmost layer first). A no-op when nothing is open.
     */
    emitEscapeKeyDown(event: KeyboardEvent): void;
    /**
     * Imperatively opens the tooltip — for programmatic control beyond hover and
     * focus (e.g. a design-system wrapper driving the tooltip from a
     * text-truncation observer). Schedules the show after the resolved
     * `openDelay` (instant when the delay is `0` or the scope's skip-delay window
     * is active) and applies the same gates as a hover / focus open: a no-op
     * while `disabled`, a no-op under `showOnOverflow` when the trigger's own
     * text is not truncated, and a no-op while an ancestor is scrolling (the
     * scroll-dismiss suppression window). For an instant, unconditional open that
     * bypasses the delay and every gate, write the `[(open)]` model directly
     * (`open.set(true)`).
     */
    show(): void;
    /**
     * Imperatively closes the tooltip, mirroring a hover-leave / blur close:
     * schedules the hide after the resolved `closeDelay` (instant when the delay
     * is `0`) and disarms the hoverable-content grace bridge. For an instant
     * close that ignores `closeDelay`, write the `[(open)]` model directly
     * (`open.set(false)`).
     */
    hide(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTooltip, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTooltip, "[forTooltip]", ["forTooltip"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "_showOnOverflowInput": { "alias": "showOnOverflow"; "required": false; "isSignal": true; }; "_hoverableContentInput": { "alias": "hoverableContent"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "escapeKeyDown": "escapeKeyDown"; }, never, never, true, never>;
}

/**
 * Element that activates the tooltip on pointer hover or keyboard focus. Apply
 * on a focusable element — preferably a `<button>` so keyboard users can reach
 * it. Receives `aria-describedby` only while the tooltip is open, per APG —
 * composed after a consumer-set **static** `aria-describedby`, which is
 * preserved rather than replaced. The hover path is gated by the shared
 * `isNonTouchPointer` predicate, so a pen hovers the tooltip while a touch tap
 * does not.
 *
 * Activating the trigger dismisses the tooltip: `pointerdown` schedules an
 * immediate close (mirroring Radix / Base UI), so the bubble doesn't cover the
 * result of a click. The focus the same press induces does NOT reopen it —
 * only keyboard focus opens the tooltip. The open-on-focus path fires solely
 * when focus was not preceded by a pointer interaction (mouse, pen, or touch):
 * hover already covers pointer users, so pointer-induced focus is ignored.
 *
 * This makes a touch tap a no-op on both the hover-open and the focus-open
 * paths, because a tap is not a hover and the APG flags hover-tooltips as
 * problematic on touch (no hover, no separate focus affordance, no obvious
 * dismiss). Keyboard focus stays the touch-accessible fallback for descriptive
 * content.
 *
 * Escape dismissal is owned by the content's document-level dismissible layer
 * (see `ForTooltipContent`), so it works from the trigger and from unrelated
 * focus alike (WCAG 2.1 SC 1.4.13) — the trigger carries no Escape listener of
 * its own.
 *
 * The root is normally resolved via DI from the enclosing `[forTooltip]`.
 * When the trigger is declared inside an `ng-template` stamped into the root
 * (e.g. via `ngTemplateOutlet`), DI resolves at the template's declaration
 * site and misses the root — pass it explicitly through the selector input,
 * `routerLink`-style: `[forTooltipTrigger]="root"` with `#root="forTooltip"`.
 */
declare class ForTooltipTrigger {
    #private;
    /**
     * Optional explicit reference to the `[forTooltip]` root, named after the
     * selector `routerLink`-style. The bare valueless attribute keeps resolving
     * the enclosing root via DI; pass the root explicitly
     * (`[forTooltipTrigger]="root"`, with `#root="forTooltip"`) when the trigger
     * is declared in an `ng-template` stamped inside the root — DI resolves at
     * the template's declaration site, so the enclosing root is invisible there.
     * The empty string (what the valueless attribute yields) is treated as unset.
     */
    readonly forTooltipTrigger: _angular_core.InputSignal<"" | ForTooltipContext>;
    protected readonly ctx: _angular_core.Signal<ForTooltipContext>;
    protected readonly describedBy: _angular_core.Signal<string | null>;
    constructor();
    protected onPointerEnter(event: PointerEvent): void;
    protected onPointerDown(event: PointerEvent): void;
    protected onPointerLeave(event: PointerEvent): void;
    protected onFocus(): void;
    protected onBlur(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTooltipTrigger, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTooltipTrigger, "[forTooltipTrigger]", ["forTooltipTrigger"], { "forTooltipTrigger": { "alias": "forTooltipTrigger"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * The tooltip bubble. Carries `role="tooltip"`, is portaled to
 * `document.body`, and is positioned by `@floating-ui/dom` while mounted.
 *
 * Default `pointer-events: none` is applied via host styles so the bubble
 * layers above content without intercepting hover. When the root opts in with
 * `hoverableContent`, `pointer-events` is dropped while open so the pointer
 * can rest over the bubble without dismissing it. Override with your own CSS
 * if needed — but per APG, do not put interactive elements inside.
 *
 * The directive does not manage DOM presence — wrap with
 * `@if (tip.open())` (using a template ref on `[forTooltip]`) so the
 * bubble mounts and unmounts with the open state and `animate.enter` /
 * `animate.leave` work natively.
 *
 * Escape is handled at the document level (outside dismissal stays implicit,
 * via hover / focus / scroll timing), so it dismisses the tooltip no matter
 * where focus lives when the
 * tooltip was hover-opened (WCAG 2.1 SC 1.4.13), and a tooltip layered over a
 * dialog is dismissed by the first Escape while the dialog stays open. No
 * initial focus move and no return focus on destroy — the surface is
 * informational and never steals focus.
 */
declare class ForTooltipContent {
    protected readonly ctx: forty_cdk_tooltip.ForTooltipContext;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTooltipContent, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTooltipContent, "[forTooltipContent]", ["forTooltipContent"], {}, {}, never, never, true, never>;
}

/**
 * Optional visual arrow inside `ForTooltipContent`. Registers itself with
 * the tooltip context so floating-ui's `arrow` middleware can position it
 * along the bubble edge that points at the trigger. Style size and color
 * yourself — the directive only sets `position`, `left`/`top`, and the
 * opposite-side offset.
 */
declare class ForTooltipArrow {
    #private;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTooltipArrow, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTooltipArrow, "[forTooltipArrow]", ["forTooltipArrow"], {}, {}, never, never, true, never>;
}

/**
 * Defaults that descendant tooltips inherit from their injector scope.
 * Configure with `provideForTooltipDefaults` either at the application root
 * or in any component's `providers` array; partial overrides merge with
 * the parent scope.
 */
interface ForTooltipDefaults extends AnchoredPositioningSeedDefaults {
    /** Open delay (ms) for tooltips that don't override `openDelay` locally. */
    openDelay: number;
    /** Close delay (ms) for tooltips that don't override `closeDelay` locally. */
    closeDelay: number;
    /**
     * Window (ms) after a peer tooltip in this scope closes during which
     * the next open is instant — keeps toolbar-style tooltips from feeling
     * sluggish on cursor movement between targets.
     */
    skipDelayDuration: number;
    /**
     * Side the tooltip is anchored to for tooltips that don't override
     * `side` locally. Library fallback `'top'`.
     */
    side: FloatingSide;
    /**
     * Alignment along the chosen `side` for tooltips that don't override
     * `align` locally. Library fallback `'center'`.
     */
    align: FloatingAlign;
    /**
     * Gap (px) between trigger and content along the main axis for tooltips
     * that don't override `sideOffset` locally.
     * Library fallback `8`.
     */
    sideOffset: number;
    /**
     * Padding (px) applied uniformly to the `flip`, `shift`, and `size`
     * middlewares for tooltips that don't override `collisionPadding`
     * locally. Library fallback `8`.
     */
    collisionPadding: number;
    /**
     * Padding (px) keeping the `[forTooltipArrow]` element that far from the
     * edges of the content, for tooltips that don't override `arrowPadding`
     * locally. Only consulted when an arrow is registered — floating-ui installs
     * the `arrow` middleware only then. Library fallback `0`.
     */
    arrowPadding: number;
    /**
     * Whether tooltips show only when the trigger's own text is truncated
     * (`scrollWidth > clientWidth`), for tooltips that don't override
     * `showOnOverflow` locally. Library fallback `false`.
     */
    showOnOverflow: boolean;
    /**
     * Whether the pointer may move into the content without dismissing the
     * tooltip, for tooltips that don't override `hoverableContent` locally.
     * Library fallback `true`, which satisfies the WCAG 2.1 SC 1.4.13
     * "Hoverable" requirement by default; opt out per scope with
     * `provideForTooltipDefaults({ hoverableContent: false })`.
     */
    hoverableContent: boolean;
}
/** Token holding the resolved tooltip defaults for the current scope. */
declare const FOR_TOOLTIP_DEFAULTS: _angular_core.InjectionToken<ForTooltipDefaults>;
/**
 * Configures forty-cdk tooltip defaults for this injector scope.
 * Partial overrides inherit unspecified keys from the parent scope (or
 * library defaults at the root). Each call establishes a new
 * coordinator scope: peer tooltips inside the scope share a skip-delay
 * window; tooltips in other scopes don't.
 *
 * @example
 * ```ts
 * // application-level
 * bootstrapApplication(App, {
 *   providers: [provideForTooltipDefaults({ openDelay: 500 })],
 * });
 *
 * // component-level override (e.g. a toolbar with its own cadence)
 * @Component({
 *   providers: [provideForTooltipDefaults({ skipDelayDuration: 100 })],
 *   ...
 * })
 * class Toolbar {}
 * ```
 */
declare function provideForTooltipDefaults(defaults?: Partial<ForTooltipDefaults>): Provider[];

export { FOR_TOOLTIP_CONTEXT, FOR_TOOLTIP_DEFAULTS, ForTooltip, ForTooltipArrow, ForTooltipContent, ForTooltipTrigger, provideForTooltipDefaults };
export type { ForTooltipContext, ForTooltipDefaults, TooltipScheduleReason };