@radix-ng/primitives 0.51.0 → 1.0.0-beta.0

package/types/radix-ng-primitives-tooltip.d.ts

@@ -1,432 +1,395 @@
 import * as _angular_core from '@angular/core';
-import { ElementRef, OnInit, ViewContainerRef, DestroyRef } from '@angular/core';
-import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
+import { InjectionToken, Provider, Signal, ElementRef } from '@angular/core';
+import * as i1 from '@radix-ng/primitives/presence';
+import { BooleanInput, NumberInput } from '@radix-ng/primitives/core';
+import * as i1$1 from '@radix-ng/primitives/popper';
+import { RdxPopperContentWrapper, RdxPopperAnchorElement } from '@radix-ng/primitives/popper';
 import * as _radix_ng_primitives_tooltip from '@radix-ng/primitives/tooltip';
-import * as rxjs from 'rxjs';
-import { Subject } from 'rxjs';
-import * as i1 from '@angular/cdk/overlay';
-import { CdkOverlayOrigin } from '@angular/cdk/overlay';
-import { RdxPositionSide, RdxPositionAlign } from '@radix-ng/primitives/core';
+import * as i1$2 from '@radix-ng/primitives/portal';
+import { RdxPortalContainer } from '@radix-ng/primitives/portal';
+import * as i1$3 from '@radix-ng/primitives/dismissable-layer';
 
-declare class RdxTooltipArrowDirective {
-    /** @ignore */
-    private readonly renderer;
-    /** @ignore */
-    private readonly rootDirective;
-    /** @ignore */
-    readonly elementRef: ElementRef<any>;
-    /**
-     * @description The width of the arrow in pixels.
-     * @default 10
-     */
-    readonly width: _angular_core.InputSignalWithTransform<number, NumberInput>;
-    /**
-     * @description The height of the arrow in pixels.
-     * @default 5
-     */
-    readonly height: _angular_core.InputSignalWithTransform<number, NumberInput>;
-    /** @ignore */
-    readonly arrowSvgElement: _angular_core.Signal<HTMLElement>;
-    /** @ignore */
-    private readonly currentArrowSvgElement;
-    /** @ignore */
-    private readonly position;
-    /** @ignore */
-    private anchorOrTriggerRect;
-    constructor();
-    /** @ignore */
-    private setAnchorOrTriggerRect;
-    /** @ignore */
-    private setPosition;
-    /** @ignore */
-    private onArrowSvgElementChangeEffect;
-    /** @ignore */
-    private onContentPositionAndArrowDimensionsChangeEffect;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipArrowDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipArrowDirective, "[rdxTooltipArrow]", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+declare class RdxTooltipPortalPresence {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipPortalPresence, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipPortalPresence, "ng-template[rdxTooltipPortalPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxPresenceDirective; inputs: {}; outputs: {}; }]>;
 }
 
-/**
- * TODO: to be removed? But it seems to be useful when controlled from outside
- */
-declare class RdxTooltipCloseDirective {
-    /** @ignore */
-    protected readonly rootDirective: _radix_ng_primitives_tooltip.RdxTooltipRootDirective;
-    /** @ignore */
-    readonly elementRef: ElementRef<any>;
-    /** @ignore */
-    private readonly renderer;
-    constructor();
-    /** @ignore */
-    private onIsControlledExternallyEffect;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipCloseDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipCloseDirective, "[rdxTooltipClose]", never, {}, {}, never, never, true, never>;
+declare class RdxTooltipHandle<Payload = unknown> {
+    private readonly rootContext;
+    private readonly triggers;
+    private readonly rootTriggerCleanups;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    open(triggerId: string): void;
+    close(): void;
+    registerRoot(rootContext: RdxTooltipContext): () => void;
+    registerTrigger(id: string, trigger: HTMLElement, payload: () => Payload | undefined): () => void;
+    context(): RdxTooltipContext | undefined;
 }
+declare function createRdxTooltipHandle<Payload = unknown>(): RdxTooltipHandle<Payload>;
 
-declare class RdxTooltipContentDirective implements OnInit {
-    /** @ignore */
-    private readonly rootDirective;
-    /** @ignore */
-    private readonly templateRef;
-    /** @ignore */
-    private readonly overlay;
-    /** @ignore */
+type RdxTrackCursorAxis = 'none' | 'x' | 'y' | 'both';
+type RdxTooltipConfig = {
+    /**
+     * How long to wait before opening the tooltip. Specified in milliseconds.
+     * @defaultValue 600
+     */
+    delay?: number;
+    /**
+     * How long to wait before closing the tooltip. Specified in milliseconds.
+     * @defaultValue 0
+     */
+    closeDelay?: number;
+    /**
+     * Another tooltip within the same provider opens instantly when this window
+     * has not yet elapsed since the previous one closed. Specified in milliseconds.
+     * @defaultValue 400
+     */
+    timeout?: number;
+    /**
+     * When `true`, the tooltip closes as the pointer leaves the trigger instead of
+     * staying open while the pointer moves over the popup.
+     * @defaultValue false
+     */
+    disableHoverablePopup?: boolean;
+};
+declare const defaultTooltipConfig: Required<RdxTooltipConfig>;
+declare const RdxTooltipDefaultsToken: InjectionToken<RdxTooltipConfig>;
+declare function provideRdxTooltipConfig(config: Partial<RdxTooltipConfig>): Provider[];
+declare function injectRdxTooltipConfig(): Required<RdxTooltipConfig>;
+
+interface RdxTooltipContext {
+    contentId: string;
+    isOpen: Signal<boolean>;
+    /** Whether the tooltip opened/closed without waiting for the delay. */
+    instant: Signal<boolean>;
+    disabled: Signal<boolean>;
+    disableHoverablePopup: Signal<boolean>;
+    trackCursorAxis: Signal<RdxTrackCursorAxis>;
+    /** The active trigger element. */
+    trigger: Signal<HTMLElement | undefined>;
+    triggers: Signal<HTMLElement[]>;
+    payload: Signal<unknown>;
+    open: (trigger?: HTMLElement, payload?: unknown) => void;
+    close: () => void;
+    /** Closes after the resolved close delay (used when hover/focus is lost). */
+    closeDelayed: () => void;
+    registerTrigger: (trigger: HTMLElement) => () => void;
+    /** Hover entered a trigger — opens after the resolved delay (or instantly). */
+    onTriggerEnter: (trigger?: HTMLElement, payload?: unknown) => void;
+    /** Hover left a trigger — cancels a pending open and closes when appropriate. */
+    onTriggerLeave: () => void;
+    setCursorPosition: (position: {
+        x: number;
+        y: number;
+    } | undefined) => void;
+    setDelays: (delay: number | undefined, closeDelay: number | undefined) => void;
+}
+declare const injectRdxTooltipContext: (optional?: boolean) => RdxTooltipContext | null;
+declare const provideRdxTooltipContext: (useFactory: () => RdxTooltipContext) => _angular_core.Provider;
+declare class RdxTooltip {
+    private readonly defaultConfig;
+    private readonly provider;
+    private readonly popper;
     private readonly destroyRef;
-    /** @ignore */
-    private readonly connectedOverlay;
-    /** @ignore */
-    readonly name: _angular_core.Signal<string>;
+    private hasAppliedDefaultOpen;
     /**
-     * @description The preferred side of the trigger to render against when open. Will be reversed when collisions occur and avoidCollisions is enabled.
-     * @default top
+     * Whether the tooltip is currently open.
      */
-    readonly side: _angular_core.InputSignal<RdxPositionSide>;
+    readonly open: _angular_core.ModelSignal<boolean>;
     /**
-     * @description The distance in pixels from the trigger.
-     * @default undefined
+     * Whether the tooltip is initially open. Uncontrolled.
      */
-    readonly sideOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * @description The preferred alignment against the trigger. May change when collisions occur.
-     * @default center
+     * How long to wait before opening the tooltip. Specified in milliseconds.
+     * Falls back to the surrounding provider, then to the global config.
      */
-    readonly align: _angular_core.InputSignal<RdxPositionAlign>;
+    readonly delay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
     /**
-     * @description An offset in pixels from the "start" or "end" alignment options.
-     * @default undefined
+     * How long to wait before closing the tooltip. Specified in milliseconds.
      */
-    readonly alignOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
     /**
-     * @description Whether to add some alternate positions of the content.
-     * @default false
+     * When `true`, the tooltip closes as the pointer leaves the trigger instead of
+     * staying open while the pointer moves over the popup.
      */
-    readonly alternatePositionsDisabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /** @description Whether to prevent `onOverlayEscapeKeyDown` handler from calling. */
-    readonly onOverlayEscapeKeyDownDisabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /** @description Whether to prevent `onOverlayOutsideClick` handler from calling. */
-    readonly onOverlayOutsideClickDisabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly disableHoverablePopup: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * @description Event handler called when the escape key is down.
-     * It can be prevented by setting `onOverlayEscapeKeyDownDisabled` input to `true`.
+     * Determines which axis the tooltip should track the cursor on.
      */
-    readonly onOverlayEscapeKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    readonly trackCursorAxis: _angular_core.InputSignal<RdxTrackCursorAxis>;
     /**
-     * @description Event handler called when a pointer event occurs outside the bounds of the component.
-     * It can be prevented by setting `onOverlayOutsideClickDisabled` input to `true`.
+     * When `true`, the tooltip will not open.
      */
-    readonly onOverlayOutsideClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * @description Event handler called after the overlay is open
+     * Associates this root with detached trigger elements.
      */
-    readonly onOpen: _angular_core.OutputEmitterRef<void>;
+    readonly handle: _angular_core.InputSignal<RdxTooltipHandle<any> | undefined>;
     /**
-     * @description Event handler called after the overlay is closed
+     * Event handler called when the open state changes.
      */
-    readonly onClosed: _angular_core.OutputEmitterRef<void>;
-    /** @ingore */
-    readonly positions: _angular_core.Signal<i1.ConnectedPosition[]>;
+    readonly onOpenChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly contentId: string;
+    readonly trigger: _angular_core.WritableSignal<HTMLElement | undefined>;
+    readonly triggers: _angular_core.WritableSignal<HTMLElement[]>;
+    readonly payload: _angular_core.WritableSignal<unknown>;
+    readonly cursorPosition: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+    } | undefined>;
+    private readonly openedInstant;
+    /** Local instant window used when this tooltip is not inside a provider. */
+    private readonly localInstant;
+    private readonly instantGroup;
+    /** Per-trigger overrides set by the active trigger, taking precedence over the root/provider. */
+    private readonly triggerDelay;
+    private readonly triggerCloseDelay;
+    private readonly resolvedDelay;
+    private readonly resolvedCloseDelay;
+    /** Whether the most recent open happened without the delay. */
+    readonly instant: Signal<boolean>;
+    private readonly virtualAnchor;
+    private readonly openTimer;
+    private readonly closeTimer;
     constructor();
-    /** @ignore */
-    ngOnInit(): void;
-    /** @ignore */
-    open(): void;
-    /** @ignore */
+    /** Opens immediately, optionally switching the active trigger/payload. */
+    show(trigger?: HTMLElement | undefined, payload?: unknown): void;
     close(): void;
-    /** @ignore */
-    positionChange(): rxjs.Observable<i1.ConnectedOverlayPositionChange>;
-    /** @ignore */
-    private connectKeydownEscape;
-    /** @ignore */
-    private connectOutsideClick;
-    /** @ignore */
-    private onAttach;
-    /** @ignore */
-    private onDetach;
-    /** @ignore */
-    private setScrollStrategy;
-    /** @ignore */
-    private setHasBackdrop;
-    /** @ignore */
-    private setDisableClose;
-    /** @ignore */
-    private setOrigin;
-    /** @ignore */
-    private setPositions;
-    /** @ignore */
-    private computePositions;
-    private onOriginChangeEffect;
-    /** @ignore */
-    private onPositionChangeEffect;
-    /** @ignore */
-    private fireOverlayNgOnChanges;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipContentDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipContentDirective, "[rdxTooltipContent]", never, { "side": { "alias": "side"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "alternatePositionsDisabled": { "alias": "alternatePositionsDisabled"; "required": false; "isSignal": true; }; "onOverlayEscapeKeyDownDisabled": { "alias": "onOverlayEscapeKeyDownDisabled"; "required": false; "isSignal": true; }; "onOverlayOutsideClickDisabled": { "alias": "onOverlayOutsideClickDisabled"; "required": false; "isSignal": true; }; }, { "onOverlayEscapeKeyDown": "onOverlayEscapeKeyDown"; "onOverlayOutsideClick": "onOverlayOutsideClick"; "onOpen": "onOpen"; "onClosed": "onClosed"; }, never, never, true, [{ directive: typeof i1.CdkConnectedOverlay; inputs: {}; outputs: {}; }]>;
+    /** Closes after the resolved close delay, e.g. when the pointer or focus leaves. */
+    scheduleClose(): void;
+    /** Hover/focus entered — open after the delay, or instantly within the instant window. */
+    onTriggerEnter(trigger?: HTMLElement | undefined, payload?: unknown): void;
+    onTriggerLeave(): void;
+    registerTrigger(trigger: HTMLElement): () => void;
+    setCursorPosition(position: {
+        x: number;
+        y: number;
+    } | undefined): void;
+    /** Applies per-trigger delay overrides from the trigger that is becoming active. */
+    setDelays(delay: number | undefined, closeDelay: number | undefined): void;
+    private applyOpen;
+    private applyClose;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltip, "[rdxTooltip]", ["rdxTooltip"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "disableHoverablePopup": { "alias": "disableHoverablePopup"; "required": false; "isSignal": true; }; "trackCursorAxis": { "alias": "trackCursorAxis"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "handle": { "alias": "handle"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "onOpenChange": "onOpenChange"; }, never, never, true, [{ directive: typeof i1$1.RdxPopper; inputs: {}; outputs: {}; }]>;
 }
 
-declare class RdxTooltipTriggerDirective {
-    /** @ignore */
-    protected readonly rootDirective: _radix_ng_primitives_tooltip.RdxTooltipRootDirective;
-    /** @ignore */
-    readonly elementRef: ElementRef<HTMLElement>;
-    /** @ignore */
-    readonly overlayOrigin: CdkOverlayOrigin;
-    /** @ignore */
-    readonly name: _angular_core.Signal<string>;
-    /** @ignore */
-    pointerenter(): void;
-    /** @ignore */
-    pointerleave(): void;
-    /** @ignore */
-    focus(): void;
-    /** @ignore */
-    blur(): void;
-    /** @ignore */
-    click(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipTriggerDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipTriggerDirective, "[rdxTooltipTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
+declare class RdxTooltipArrow {
+    protected readonly rootContext: _radix_ng_primitives_tooltip.RdxTooltipContext;
+    private readonly wrapper;
+    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly align: _angular_core.Signal<"start" | "center" | "end" | undefined>;
+    protected readonly uncentered: _angular_core.Signal<boolean>;
+    protected readonly isVisuallyHidden: boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipArrow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipArrow, "[rdxTooltipArrow]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperArrow; inputs: {}; outputs: {}; }]>;
 }
 
-type EventType = 'cdkOverlayOutsideClick' | 'cdkOverlayEscapeKeyDown';
-type EventTypeCapitalized<R extends EventType = EventType> = Capitalize<R>;
-type EventTypeAsPrimitiveConfigKey<R extends EventType = EventType> = `prevent${EventTypeCapitalized<R>}`;
-type PrimitiveConfig = {
-    [value in EventTypeAsPrimitiveConfigKey]?: boolean;
-};
-type PrimitiveConfigs = Map<object, PrimitiveConfig>;
-
-declare class RdxTooltipAnchorDirective {
-    /**
-     * @ignore
-     * If outside the rootDirective then null, otherwise the rootDirective directive - with optional `true` passed in as the first param.
-     * If outside the rootDirective and non-null value that means the html structure is wrong - tooltip inside tooltip.
-     * */
-    protected rootDirective: RdxTooltipRootDirective | null;
-    /** @ignore */
-    readonly elementRef: ElementRef<any>;
-    /** @ignore */
-    readonly overlayOrigin: CdkOverlayOrigin;
-    /** @ignore */
-    readonly document: Document;
-    /** @ignore */
-    readonly name: _angular_core.Signal<string>;
-    /** @ignore */
-    click(): void;
-    /** @ignore */
-    setRoot(root: RdxTooltipRootDirective): void;
-    private emitOutsideClick;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipAnchorDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipAnchorDirective, "[rdxTooltipAnchor]", ["rdxTooltipAnchor"], {}, {}, never, never, true, [{ directive: typeof i1.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
+/**
+ * The tooltip popup. Renders the content with `role="tooltip"`.
+ */
+declare class RdxTooltipPopup {
+    protected readonly rootContext: _radix_ng_primitives_tooltip.RdxTooltipContext;
+    private readonly wrapper;
+    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly align: _angular_core.Signal<"start" | "center" | "end" | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipPopup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipPopup, "[rdxTooltipPopup]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperContent; inputs: {}; outputs: {}; }]>;
 }
 
-declare enum RdxTooltipState {
-    OPEN = "open",
-    CLOSED = "closed"
-}
-declare enum RdxTooltipAction {
-    OPEN = "open",
-    CLOSE = "close"
-}
-declare enum RdxTooltipAttachDetachEvent {
-    ATTACH = "attach",
-    DETACH = "detach"
-}
-declare enum RdxTooltipAnimationStatus {
-    OPEN_STARTED = "open_started",
-    OPEN_ENDED = "open_ended",
-    CLOSED_STARTED = "closed_started",
-    CLOSED_ENDED = "closed_ended"
+/**
+ * Moves the tooltip to a different part of the DOM.
+ */
+declare class RdxTooltipPortal {
+    readonly container: _angular_core.InputSignal<RdxPortalContainer>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipPortal, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipPortal, "[rdxTooltipPortal]", never, { "container": { "alias": "container"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$2.RdxPortal; inputs: { "container": "container"; }; outputs: {}; }]>;
 }
 
-declare class RdxTooltipRootDirective {
-    /** @ignore */
-    readonly uniqueId: _angular_core.WritableSignal<number>;
-    /** @ignore */
-    readonly name: _angular_core.Signal<string>;
+/**
+ * Positions the tooltip popup against its trigger (or a custom anchor).
+ */
+declare class RdxTooltipPositioner {
+    protected readonly rootContext: _radix_ng_primitives_tooltip.RdxTooltipContext;
+    protected readonly wrapper: RdxPopperContentWrapper;
+    private readonly destroyRef;
+    private readonly dismissableLayer;
+    private readonly elementRef;
     /**
-     * @description The anchor directive that comes form outside the tooltip rootDirective
-     * @default undefined
+     * An element to position the popup against. Defaults to the trigger.
      */
-    readonly anchor: _angular_core.InputSignal<RdxTooltipAnchorDirective | undefined>;
+    readonly anchor: _angular_core.InputSignal<RdxPopperAnchorElement>;
     /**
-     * @description The open state of the tooltip when it is initially rendered. Use when you do not need to control its open state.
-     * @default false
+     * The preferred side of the anchor to render against when open.
      */
-    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly side: _angular_core.InputSignal<"top" | "right" | "bottom" | "left">;
     /**
-     * @description The controlled state of the tooltip. `open` input take precedence of `defaultOpen` input.
-     * @default undefined
-     */
-    readonly open: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanInput>;
-    /**
-     * To customise the open delay for a specific tooltip.
-     */
-    readonly openDelay: _angular_core.InputSignalWithTransform<number, NumberInput>;
-    /**
-     * To customise the close delay for a specific tooltip.
-     */
-    readonly closeDelay: _angular_core.InputSignalWithTransform<number, NumberInput>;
-    /**
-     * @description Whether to control the state of the tooltip from external. Use in conjunction with `open` input.
-     * @default undefined
-     */
-    readonly externalControl: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanInput>;
-    /**
-     * @description Whether to take into account CSS opening/closing animations.
-     * @default false
-     */
-    readonly cssAnimation: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /**
-     * @description Whether to take into account CSS opening animations. `cssAnimation` input must be set to 'true'
-     * @default false
-     */
-    readonly cssOpeningAnimation: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /**
-     * @description Whether to take into account CSS closing animations. `cssAnimation` input must be set to 'true'
-     * @default false
-     */
-    readonly cssClosingAnimation: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /** @ignore */
-    readonly cssAnimationStatus: _angular_core.WritableSignal<RdxTooltipAnimationStatus | null>;
-    /** @ignore */
-    readonly contentDirective: _angular_core.Signal<RdxTooltipContentDirective>;
-    /** @ignore */
-    readonly triggerDirective: _angular_core.Signal<RdxTooltipTriggerDirective>;
-    /** @ignore */
-    readonly arrowDirective: _angular_core.Signal<_radix_ng_primitives_tooltip.RdxTooltipArrowDirective | undefined>;
-    /** @ignore */
-    readonly closeDirective: _angular_core.Signal<_radix_ng_primitives_tooltip.RdxTooltipCloseDirective | undefined>;
-    /** @ignore */
-    readonly contentAttributesComponent: _angular_core.Signal<_radix_ng_primitives_tooltip.RdxTooltipContentAttributesComponent | undefined>;
-    /** @ignore */
-    private readonly internalAnchorDirective;
-    /** @ignore */
-    readonly viewContainerRef: ViewContainerRef;
-    /** @ignore */
-    readonly rdxCdkEventService: {
-        document: Document;
-        destroyRef: DestroyRef;
-        ngZone: _angular_core.NgZone;
-        renderer2: _angular_core.Renderer2;
-        window: Window & typeof globalThis;
-        primitiveConfigs?: PrimitiveConfigs;
-        onDestroyCallbacks: Set<() => void>;
-        #clickDomRootEventCallbacks: Set<(event: MouseEvent) => void>;
-        registerPrimitive<T extends object>(primitiveInstance: T): void;
-        deregisterPrimitive<T extends object>(primitiveInstance: T): void;
-        preventPrimitiveFromCdkEvent<T extends object>(primitiveInstance: T, eventType: EventType): void;
-        allowPrimitiveForCdkEvent<T extends object>(primitiveInstance: T, eventType: EventType): void;
-        preventPrimitiveFromCdkMultiEvents<T extends object>(primitiveInstance: T, eventTypes: EventType[]): void;
-        allowPrimitiveForCdkMultiEvents<T extends object>(primitiveInstance: T, eventTypes: EventType[]): void;
-        setPreventPrimitiveFromCdkMixEvents<T extends object>(primitiveInstance: T, eventTypes: PrimitiveConfig): void;
-        primitivePreventedFromCdkEvent<T extends object>(primitiveInstance: T, eventType: EventType): boolean | undefined;
-        addClickDomRootEventCallback(callback: (event: MouseEvent) => void): void;
-        removeClickDomRootEventCallback(callback: (event: MouseEvent) => void): boolean;
-        #setPreventPrimitiveFromCdkEvent<T extends object, R extends EventType, K extends PrimitiveConfig[`prevent${Capitalize<R>}`]>(primitiveInstance: T, eventType: R, value: K): void;
-        #registerOnDestroyCallbacks(): void;
-        #listenToClickDomRootEvent(): void;
-    } | null;
-    /** @ignore */
-    readonly destroyRef: DestroyRef;
-    /** @ignore */
-    readonly state: _angular_core.WritableSignal<RdxTooltipState>;
-    /** @ignore */
-    readonly attachDetachEvent: _angular_core.WritableSignal<RdxTooltipAttachDetachEvent>;
-    /** @ignore */
-    private readonly isFirstDefaultOpen;
-    /** @ignore */
-    readonly anchorDirective: _angular_core.Signal<RdxTooltipAnchorDirective | undefined>;
-    /** @ignore */
-    readonly actionSubject$: Subject<RdxTooltipAction>;
+     * The distance in pixels from the anchor.
+     */
+    readonly sideOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The preferred alignment against the anchor.
+     */
+    readonly align: _angular_core.InputSignal<"start" | "center" | "end">;
+    /**
+     * An offset in pixels from the `start` or `end` alignment options.
+     */
+    readonly alignOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The padding between the arrow and the edges of the content.
+     */
+    readonly arrowPadding: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * When `true`, overrides the `side` and `align` preferences to prevent collisions with boundary edges.
+     */
+    readonly avoidCollisions: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The element used as the collision boundary.
+     */
+    readonly collisionBoundary: _angular_core.InputSignal<ElementRef<HTMLElement> | ElementRef<HTMLElement>[] | undefined>;
+    /**
+     * The distance in pixels from the boundary edges where collision detection should occur.
+     */
+    readonly collisionPadding: _angular_core.InputSignal<number | Partial<Record<"top" | "right" | "bottom" | "left", number>>>;
+    /**
+     * The sticky behavior on the `align` axis.
+     */
+    readonly sticky: _angular_core.InputSignal<"partial" | "always">;
+    /**
+     * Whether to hide the content when the trigger becomes fully occluded.
+     */
+    readonly hideWhenDetached: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The CSS position strategy used by Floating UI.
+     */
+    readonly positionStrategy: _angular_core.InputSignal<"fixed" | "absolute">;
+    /**
+     * Whether to update the position of the floating element on every animation frame if required.
+     */
+    readonly updatePositionStrategy: _angular_core.InputSignal<"always" | "optimized">;
+    /**
+     * Emits when the element is placed.
+     */
+    readonly placed: _angular_core.OutputRef<void>;
+    /**
+     * Event handler called when the escape key is down. Can be prevented.
+     */
+    readonly escapeKeyDown: _angular_core.OutputRef<KeyboardEvent>;
+    /**
+     * Event handler called when a `pointerdown` event happens outside of the `DismissableLayer`. Can be prevented.
+     */
+    readonly pointerDownOutside: _angular_core.OutputRef<PointerEvent>;
+    private readonly triggerEl;
+    private readonly containerEl;
+    private readonly graceArea;
+    private readonly afterNextRender;
     constructor();
-    /** @ignore */
-    getAnimationParamsSnapshot(): {
-        cssAnimation: boolean;
-        cssOpeningAnimation: boolean;
-        cssClosingAnimation: boolean;
-        cssAnimationStatus: RdxTooltipAnimationStatus | null;
-        attachDetachEvent: RdxTooltipAttachDetachEvent;
-        state: RdxTooltipState;
-        canEmitOnOpenOrOnClosed: boolean;
-    };
-    /** @ignore */
-    controlledExternally(): _angular_core.InputSignalWithTransform<boolean | undefined, BooleanInput>;
-    /** @ignore */
-    firstDefaultOpen(): boolean;
-    /** @ignore */
-    handleOpen(): void;
-    /** @ignore */
-    handleClose(closeButton?: boolean): void;
-    /** @ignore */
-    handleToggle(): void;
-    /** @ignore */
-    isOpen(state?: RdxTooltipState): boolean;
-    /** @ignore */
-    private setState;
-    /** @ignore */
-    private openContent;
-    /** @ignore */
-    private closeContent;
-    /** @ignore */
-    private emitOnOpen;
-    /** @ignore */
-    private emitOnClosed;
-    /** @ignore */
-    private ifOpenOrCloseWithoutAnimations;
-    /** @ignore */
-    private ifOpenOrCloseWithAnimations;
-    /** @ignore */
-    private openOrClose;
-    /** @ignore */
-    private emitOnOpenOrOnClosed;
-    /** @ignore */
-    private canEmitOnOpenOrOnClosed;
-    /** @ignore */
-    private onStateChangeEffect;
-    /** @ignore */
-    private onCssAnimationStatusChangeChangeEffect;
-    /** @ignore */
-    private emitOpenOrClosedEventEffect;
-    /** @ignore */
-    private onOpenChangeEffect;
-    /** @ignore */
-    private onIsFirstDefaultOpenChangeEffect;
-    /** @ignore */
-    private onAnchorChangeEffect;
-    /** @ignore */
-    private actionSubscription;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipRootDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipRootDirective, "[rdxTooltipRoot]", ["rdxTooltipRoot"], { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "externalControl": { "alias": "externalControl"; "required": false; "isSignal": true; }; "cssAnimation": { "alias": "cssAnimation"; "required": false; "isSignal": true; }; "cssOpeningAnimation": { "alias": "cssOpeningAnimation"; "required": false; "isSignal": true; }; "cssClosingAnimation": { "alias": "cssClosingAnimation"; "required": false; "isSignal": true; }; }, {}, ["contentDirective", "triggerDirective", "arrowDirective", "closeDirective", "contentAttributesComponent", "internalAnchorDirective"], never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipPositioner, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipPositioner, "[rdxTooltipPositioner]", never, { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionBoundary": { "alias": "collisionBoundary"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "positionStrategy": { "alias": "positionStrategy"; "required": false; "isSignal": true; }; "updatePositionStrategy": { "alias": "updatePositionStrategy"; "required": false; "isSignal": true; }; }, { "placed": "placed"; "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; }, never, never, true, [{ directive: typeof i1$3.RdxDismissableLayer; inputs: {}; outputs: {}; }, { directive: typeof i1$1.RdxPopperContentWrapper; inputs: { "anchor": "anchor"; "side": "side"; "sideOffset": "sideOffset"; "align": "align"; "alignOffset": "alignOffset"; "arrowPadding": "arrowPadding"; "avoidCollisions": "avoidCollisions"; "collisionBoundary": "collisionBoundary"; "collisionPadding": "collisionPadding"; "sticky": "sticky"; "hideWhenDetached": "hideWhenDetached"; "positionStrategy": "positionStrategy"; "updatePositionStrategy": "updatePositionStrategy"; }; outputs: {}; }]>;
 }
 
-declare class RdxTooltipContentAttributesComponent {
-    /** @ignore */
-    protected readonly rootDirective: _radix_ng_primitives_tooltip.RdxTooltipRootDirective;
-    /** @ignore */
-    readonly name: _angular_core.Signal<string>;
-    /** @ignore */
-    readonly disableAnimation: _angular_core.Signal<boolean>;
-    /** @ignore */
-    protected onAnimationStart(_: AnimationEvent): void;
-    /** @ignore */
-    protected onAnimationEnd(_: AnimationEvent): void;
-    /** @ignore */
-    protected pointerenter(): void;
-    /** @ignore */
-    protected pointerleave(): void;
-    /** @ignore */
-    protected focus(): void;
-    /** @ignore */
-    protected blur(): void;
-    /** @ignore */
-    private canAnimate;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipContentAttributesComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RdxTooltipContentAttributesComponent, "[rdxTooltipContentAttributes]", never, {}, {}, never, ["*"], true, never>;
+type TooltipInstantController = {
+    /** Whether the next tooltip in the group should open without waiting for the delay. */
+    isInstant: Signal<boolean>;
+    /** Call when a tooltip opens — leaves the group in the instant phase. */
+    onOpen: () => void;
+    /** Call when a tooltip closes — keeps the group instant for `timeout` ms, then re-arms the delay. */
+    onClose: () => void;
+};
+
+interface RdxTooltipProviderContext {
+    /** Default open delay for tooltips in this group, in milliseconds. */
+    delay: Signal<number | undefined>;
+    /** Default close delay for tooltips in this group, in milliseconds. */
+    closeDelay: Signal<number | undefined>;
+    /** Whether sibling tooltips should currently open instantly. */
+    isInstant: Signal<boolean>;
+    /** Notifies the group that a tooltip has opened. */
+    onOpen: () => void;
+    /** Notifies the group that a tooltip has closed. */
+    onClose: () => void;
+}
+declare const injectRdxTooltipProviderContext: (optional?: boolean) => RdxTooltipProviderContext | null;
+declare const provideRdxTooltipProviderContext: (useFactory: () => RdxTooltipProviderContext) => _angular_core.Provider;
+/**
+ * Shares delay configuration and an instant-open window across a group of tooltips.
+ * Once one tooltip opens, adjacent ones open instantly until `timeout` ms after the last close.
+ */
+declare class RdxTooltipProvider {
+    private readonly defaultConfig;
+    private readonly destroyRef;
+    /**
+     * How long to wait before opening tooltips in this group. Specified in milliseconds.
+     */
+    readonly delay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * How long to wait before closing tooltips in this group. Specified in milliseconds.
+     */
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * The window during which an adjacent tooltip opens instantly. Specified in milliseconds.
+     */
+    readonly timeout: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    readonly instant: TooltipInstantController;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipProvider, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipProvider, "[rdxTooltipProvider]", ["rdxTooltipProvider"], { "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "timeout": { "alias": "timeout"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class RdxTooltipModule {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxTooltipModule, never, [typeof RdxTooltipArrowDirective, typeof RdxTooltipCloseDirective, typeof RdxTooltipContentDirective, typeof RdxTooltipTriggerDirective, typeof RdxTooltipRootDirective, typeof RdxTooltipAnchorDirective, typeof RdxTooltipContentAttributesComponent], [typeof RdxTooltipArrowDirective, typeof RdxTooltipCloseDirective, typeof RdxTooltipContentDirective, typeof RdxTooltipTriggerDirective, typeof RdxTooltipRootDirective, typeof RdxTooltipAnchorDirective, typeof RdxTooltipContentAttributesComponent]>;
-    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxTooltipModule>;
+declare class RdxTooltipTrigger {
+    private readonly parentRootContext;
+    readonly elementRef: ElementRef<HTMLElement>;
+    private readonly generatedId;
+    /**
+     * Associates this trigger with a detached tooltip root.
+     */
+    readonly handle: _angular_core.InputSignal<RdxTooltipHandle<any> | undefined>;
+    /**
+     * Data associated with this trigger while it is active.
+     */
+    readonly payload: _angular_core.InputSignal<unknown>;
+    /**
+     * ID used to identify this trigger when opening a detached tooltip imperatively.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether the tooltip should close when the trigger is clicked.
+     * @defaultValue true
+     */
+    readonly closeOnClick: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether this trigger is disabled. A disabled trigger never opens the tooltip.
+     * @defaultValue false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Overrides the open delay (ms) for this trigger. Falls back to the root/provider/global delay.
+     */
+    readonly delay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * Overrides the close delay (ms) for this trigger. Falls back to the root/provider/global delay.
+     */
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    readonly userOnPointerDown: _angular_core.InputSignal<((event: PointerEvent) => void | boolean | Promise<void | boolean> | undefined) | undefined>;
+    protected readonly triggerId: _angular_core.Signal<string>;
+    protected readonly rootContext: _angular_core.Signal<_radix_ng_primitives_tooltip.RdxTooltipContext | null>;
+    /** Disabled if either the root or this trigger is disabled. */
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    /** Whether this specific trigger is the active anchor of an open tooltip. */
+    protected readonly isOpen: _angular_core.Signal<boolean>;
+    private readonly isPointerDown;
+    private readonly hasPointerMoveOpened;
+    constructor();
+    protected handleFocus(): void;
+    protected handleBlur(): void;
+    protected handleClick(): void;
+    protected handlePointerMove(event: PointerEvent): void;
+    protected handlePointerLeave(): void;
+    protected handlePointerDown(event: PointerEvent): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipTrigger, "[rdxTooltipTrigger]", never, { "handle": { "alias": "handle"; "required": false; "isSignal": true; }; "payload": { "alias": "payload"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "userOnPointerDown": { "alias": "rdxOnPointerDown"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperAnchor; inputs: {}; outputs: {}; }]>;
 }
 
-export { RdxTooltipAnchorDirective, RdxTooltipArrowDirective, RdxTooltipCloseDirective, RdxTooltipContentAttributesComponent, RdxTooltipContentDirective, RdxTooltipModule, RdxTooltipRootDirective, RdxTooltipTriggerDirective };
+declare const tooltipImports: (typeof RdxTooltipPortalPresence)[];
+
+export { RdxTooltip, RdxTooltipArrow, RdxTooltipDefaultsToken, RdxTooltipHandle, RdxTooltipPopup, RdxTooltipPortal, RdxTooltipPortalPresence, RdxTooltipPositioner, RdxTooltipProvider, RdxTooltipTrigger, createRdxTooltipHandle, defaultTooltipConfig, injectRdxTooltipConfig, injectRdxTooltipContext, injectRdxTooltipProviderContext, provideRdxTooltipConfig, provideRdxTooltipContext, provideRdxTooltipProviderContext, tooltipImports };
+export type { RdxTooltipConfig, RdxTooltipContext, RdxTooltipProviderContext, RdxTrackCursorAxis };