ng-primitives 0.120.4 → 0.121.0

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

@@ -0,0 +1,691 @@
+import * as ng_primitives_portal from 'ng-primitives/portal';
+import { NgpOffset, NgpFlip, NgpShift, NgpOverlayArrowState, NgpOverlayArrowProps, NgpOverlayContent, NgpPosition, NgpOverlay, NgpOffsetInput, NgpFlipInput, NgpShiftInput } from 'ng-primitives/portal';
+export { NgpOverlayArrowProps as NgpTooltipArrowProps, NgpOverlayArrowState as NgpTooltipArrowState, injectOverlayContext as injectTooltipContext } from 'ng-primitives/portal';
+import * as _angular_core from '@angular/core';
+import { Provider, WritableSignal, Signal, OnDestroy, ElementRef } from '@angular/core';
+import { Placement } from '@floating-ui/dom';
+import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
+import * as ng_primitives_state from 'ng-primitives/state';
+import { StateInjectionOptions } from 'ng-primitives/state';
+
+interface NgpTooltipConfig {
+    /**
+     * Define the offset of the tooltip relative to the trigger.
+     * Can be a number (applies to mainAxis) or an object with mainAxis, crossAxis, and alignmentAxis.
+     * @default 4
+     */
+    offset: NgpOffset;
+    /**
+     * Define the placement of the tooltip relative to the trigger.
+     * @default 'top'
+     */
+    placement: Placement;
+    /**
+     * Define the delay before the tooltip is shown.
+     * @default 0
+     */
+    showDelay: number;
+    /**
+     * Define the delay before the tooltip is hidden.
+     * @default 500
+     */
+    hideDelay: number;
+    /**
+     * Define whether the tooltip should flip when there is not enough space for the tooltip.
+     * Can be a boolean to enable/disable, or an object with padding and fallbackPlacements options.
+     * @default true
+     */
+    flip: NgpFlip;
+    /**
+     * Define the container element or selector into which the tooltip should be attached.
+     * @default 'body'
+     */
+    container: HTMLElement | string | null;
+    /**
+     * Whether the tooltip should only show when the trigger element overflows.
+     * @default false
+     */
+    showOnOverflow: boolean;
+    /**
+     * Whether to use the text content of the trigger element as the tooltip content.
+     * @default true
+     */
+    useTextContent: boolean;
+    /**
+     * Configure shift behavior to keep the tooltip in view.
+     * Can be a boolean to enable/disable, or an object with padding and limiter options.
+     * @default undefined (enabled by default in overlay)
+     */
+    shift: NgpShift;
+    /**
+     * Whether to track the trigger element position on every animation frame.
+     * Useful for moving elements like slider thumbs.
+     * @default false
+     */
+    trackPosition: boolean;
+    /**
+     * Defines how the tooltip behaves when the window is scrolled.
+     * @default 'reposition'
+     */
+    scrollBehavior: 'reposition' | 'close';
+    /**
+     * Cooldown duration in milliseconds.
+     * When moving from one tooltip to another within this duration,
+     * the showDelay is skipped for the new tooltip.
+     * @default 300
+     */
+    cooldown: number;
+    /**
+     * Whether hovering the tooltip content keeps it open while moving from the trigger.
+     * @default false
+     */
+    hoverableContent: boolean;
+}
+/**
+ * Provide the default Tooltip configuration
+ * @param config The Tooltip configuration
+ * @returns The provider
+ */
+declare function provideTooltipConfig(config: Partial<NgpTooltipConfig>): Provider[];
+
+declare class NgpTooltipArrow {
+    /**
+     * Padding between the arrow and the edges of the tooltip.
+     * This prevents the arrow from overflowing the rounded corners.
+     */
+    readonly padding: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    protected readonly state: ng_primitives_portal.NgpOverlayArrowState;
+    /**
+     * Set the padding between the arrow and the edges of the tooltip.
+     * @param value The padding value in pixels
+     */
+    setPadding(value: number | undefined): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpTooltipArrow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpTooltipArrow, "[ngpTooltipArrow]", ["ngpTooltipArrow"], { "padding": { "alias": "ngpTooltipArrowPadding"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const NgpTooltipArrowStateToken: _angular_core.InjectionToken<_angular_core.WritableSignal<NgpOverlayArrowState>>;
+declare const ngpTooltipArrow: ({ padding }: NgpOverlayArrowProps) => NgpOverlayArrowState;
+declare const injectTooltipArrowState: {
+    (): _angular_core.Signal<NgpOverlayArrowState>;
+    (options: ng_primitives_state.StateInjectionOptions): _angular_core.Signal<NgpOverlayArrowState | null>;
+    (options?: ng_primitives_state.StateInjectionOptions): _angular_core.Signal<NgpOverlayArrowState> | _angular_core.Signal<NgpOverlayArrowState | null>;
+};
+declare const provideTooltipArrowState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+
+interface TooltipHoverBridgePoint {
+    x: number;
+    y: number;
+}
+
+interface NgpTooltipTriggerState<T> {
+    /** Access the tooltip template ref. */
+    readonly tooltip: WritableSignal<NgpOverlayContent<T> | string | null>;
+    /**
+     * Define if the trigger should be disabled. This will prevent the tooltip from being shown or hidden from interactions.
+     * @default false
+     */
+    readonly disabled: Signal<boolean>;
+    /**
+     * Define the placement of the tooltip relative to the trigger.
+     * @default 'top'
+     */
+    readonly placement: Signal<NgpTooltipPlacement>;
+    /**
+     * Define the offset of the tooltip relative to the trigger.
+     * Can be a number (applies to mainAxis) or an object with mainAxis, crossAxis, and alignmentAxis.
+     * @default 0
+     */
+    readonly offset: Signal<NgpOffset>;
+    /**
+     * Define the delay before the tooltip is displayed.
+     * @default 500
+     */
+    readonly showDelay: Signal<number>;
+    /**
+     * Define the delay before the tooltip is hidden.
+     * @default 0
+     */
+    readonly hideDelay: Signal<number>;
+    /**
+     * Define whether the tooltip should flip when there is not enough space for the tooltip.
+     * Can be a boolean to enable/disable, or an object with padding and fallbackPlacements options.
+     * @default true
+     */
+    readonly flip: Signal<NgpFlip>;
+    /**
+     * Configure shift behavior to keep the tooltip in view.
+     * Can be a boolean to enable/disable, or an object with padding and limiter options.
+     * @default undefined (enabled by default in overlay)
+     */
+    readonly shift: Signal<NgpShift>;
+    /**
+     * Define the container in which the tooltip should be attached.
+     * @default document.body
+     */
+    readonly container: Signal<HTMLElement | string | null>;
+    /**
+     * Define whether the tooltip should only show when the trigger element overflows.
+     * @default false
+     */
+    readonly showOnOverflow: Signal<boolean>;
+    /**
+     * Define an anchor element for positioning the tooltip.
+     * If provided, the tooltip will be positioned relative to this element instead of the trigger.
+     */
+    readonly anchor: Signal<HTMLElement | null>;
+    /**
+     * Provide context to the tooltip. This can be used to pass data to the tooltip content.
+     */
+    readonly context: Signal<T | undefined>;
+    /**
+     * Define whether to use the text content of the trigger element as the tooltip content.
+     * When enabled, the tooltip will display the text content of the trigger element.
+     * @default true
+     */
+    readonly useTextContent: Signal<boolean>;
+    /**
+     * Define whether to track the trigger element position on every animation frame.
+     * Useful for moving elements like slider thumbs.
+     * @default false
+     */
+    readonly trackPosition: Signal<boolean>;
+    /**
+     * Programmatic position for the tooltip. When provided, the tooltip
+     * will be positioned at these coordinates instead of the trigger element.
+     * Use with trackPosition="true" for smooth cursor following.
+     */
+    readonly position: Signal<NgpPosition | null>;
+    /**
+     * Defines how the tooltip behaves when the window is scrolled.
+     * @default 'reposition'
+     */
+    readonly scrollBehavior: Signal<'reposition' | 'close'>;
+    /**
+     * Define the cooldown duration in milliseconds.
+     * When moving from one tooltip to another within this duration,
+     * the showDelay is skipped for the new tooltip.
+     * @default 300
+     */
+    readonly cooldown: Signal<number>;
+    /**
+     * Whether hovering tooltip content keeps the tooltip open.
+     * @default false
+     */
+    readonly hoverableContent: Signal<boolean>;
+    /**
+     * The overlay that manages the tooltip
+     * @internal
+     */
+    readonly overlay: WritableSignal<NgpOverlay<T | string> | null>;
+    /**
+     * The unique id of the tooltip.
+     */
+    readonly tooltipId: Signal<string | undefined>;
+    /**
+     * The open state of the tooltip.
+     * @internal
+     */
+    readonly open: Signal<boolean>;
+    /**
+     * Determine if the trigger element has overflow.
+     */
+    readonly hasOverflow: Signal<boolean>;
+    /**
+     * Tracks whether pointer is currently over tooltip content.
+     */
+    readonly contentHovered: Signal<boolean>;
+    /**
+     * Current pointer grace polygon used while crossing trigger -> tooltip.
+     */
+    readonly hoverBridgePolygon: Signal<TooltipHoverBridgePoint[] | null>;
+    /**
+     * Show the tooltip programmatically (skips cooldown so multiple tooltips can coexist).
+     */
+    show: () => void;
+    /**
+     * Hide the tooltip.
+     */
+    hide: () => void;
+    /**
+     * Set the tooltip id.
+     */
+    setTooltipId: (id: string) => void;
+    /**
+     * Called by tooltip content when pointer enters the tooltip.
+     * @internal
+     */
+    onTooltipHoverStart: () => void;
+    /**
+     * Called by tooltip content when pointer leaves the tooltip.
+     * @internal
+     */
+    onTooltipHoverEnd: () => void;
+    destroy: () => void;
+}
+interface NgpTooltipTriggerProps<T> {
+    /** Access the tooltip template ref. */
+    readonly tooltip?: Signal<NgpOverlayContent<T> | string | null>;
+    /**
+     * Define if the trigger should be disabled. This will prevent the tooltip from being shown or hidden from interactions.
+     * @default false
+     */
+    readonly disabled?: Signal<boolean>;
+    /**
+     * Define the placement of the tooltip relative to the trigger.
+     * @default 'top'
+     */
+    readonly placement?: Signal<NgpTooltipPlacement>;
+    /**
+     * Define the offset of the tooltip relative to the trigger.
+     * Can be a number (applies to mainAxis) or an object with mainAxis, crossAxis, and alignmentAxis.
+     * @default 0
+     */
+    readonly offset?: Signal<NgpOffset>;
+    /**
+     * Define the delay before the tooltip is displayed.
+     * @default 500
+     */
+    readonly showDelay?: Signal<number>;
+    /**
+     * Define the delay before the tooltip is hidden.
+     * @default 0
+     */
+    readonly hideDelay?: Signal<number>;
+    /**
+     * Define whether the tooltip should flip when there is not enough space for the tooltip.
+     * Can be a boolean to enable/disable, or an object with padding and fallbackPlacements options.
+     * @default true
+     */
+    readonly flip?: Signal<NgpFlip>;
+    /**
+     * Configure shift behavior to keep the tooltip in view.
+     * Can be a boolean to enable/disable, or an object with padding and limiter options.
+     * @default undefined (enabled by default in overlay)
+     */
+    readonly shift?: Signal<NgpShift>;
+    /**
+     * Define the container in which the tooltip should be attached.
+     * @default document.body
+     */
+    readonly container?: Signal<HTMLElement | string | null>;
+    /**
+     * Define whether the tooltip should only show when the trigger element overflows.
+     * @default false
+     */
+    readonly showOnOverflow?: Signal<boolean>;
+    /**
+     * Define an anchor element for positioning the tooltip.
+     * If provided, the tooltip will be positioned relative to this element instead of the trigger.
+     */
+    readonly anchor?: Signal<HTMLElement | null>;
+    /**
+     * Provide context to the tooltip. This can be used to pass data to the tooltip content.
+     */
+    readonly context?: Signal<T | undefined>;
+    /**
+     * Define whether to use the text content of the trigger element as the tooltip content.
+     * When enabled, the tooltip will display the text content of the trigger element.
+     * @default true
+     */
+    readonly useTextContent?: Signal<boolean>;
+    /**
+     * Define whether to track the trigger element position on every animation frame.
+     * Useful for moving elements like slider thumbs.
+     * @default false
+     */
+    readonly trackPosition?: Signal<boolean>;
+    /**
+     * Programmatic position for the tooltip. When provided, the tooltip
+     * will be positioned at these coordinates instead of the trigger element.
+     * Use with trackPosition="true" for smooth cursor following.
+     */
+    readonly position?: Signal<NgpPosition | null>;
+    /**
+     * Defines how the tooltip behaves when the window is scrolled.
+     * @default 'reposition'
+     */
+    readonly scrollBehavior?: Signal<'reposition' | 'close'>;
+    /**
+     * Define the cooldown duration in milliseconds.
+     * When moving from one tooltip to another within this duration,
+     * the showDelay is skipped for the new tooltip.
+     * @default 300
+     */
+    readonly cooldown?: Signal<number>;
+    /**
+     * Whether hovering tooltip content keeps the tooltip open.
+     * @default false
+     */
+    readonly hoverableContent?: Signal<boolean>;
+}
+declare const NgpTooltipTriggerStateToken: _angular_core.InjectionToken<WritableSignal<{
+    tooltip: WritableSignal<string | NgpOverlayContent<unknown> | null>;
+    disabled: Signal<boolean>;
+    placement: Signal<NgpTooltipPlacement>;
+    offset: Signal<NgpOffset>;
+    showDelay: Signal<number>;
+    hideDelay: Signal<number>;
+    flip: Signal<NgpFlip>;
+    shift: Signal<NgpShift>;
+    container: Signal<string | HTMLElement | null>;
+    showOnOverflow: Signal<boolean>;
+    anchor: Signal<HTMLElement | null>;
+    context: Signal<unknown>;
+    useTextContent: Signal<boolean>;
+    trackPosition: Signal<boolean>;
+    position: Signal<NgpPosition | null>;
+    scrollBehavior: Signal<"reposition" | "close">;
+    cooldown: Signal<number>;
+    hoverableContent: Signal<boolean>;
+    overlay: WritableSignal<NgpOverlay<unknown> | null>;
+    tooltipId: WritableSignal<string | undefined>;
+    open: Signal<boolean>;
+    hasOverflow: Signal<boolean>;
+    contentHovered: WritableSignal<boolean>;
+    hoverBridgePolygon: WritableSignal<TooltipHoverBridgePoint[] | null>;
+    show: () => void;
+    hide: () => void;
+    setTooltipId: (id: string) => void;
+    onTooltipHoverStart: () => void;
+    onTooltipHoverEnd: () => void;
+    destroy: () => void;
+}>>;
+declare const ngpTooltipTrigger: <T>({ tooltip: _tooltip, disabled, placement, offset, showDelay, hideDelay, flip, shift, container, showOnOverflow, anchor, context, useTextContent, trackPosition, position, scrollBehavior, cooldown, hoverableContent, }: NgpTooltipTriggerProps<T>) => {
+    tooltip: WritableSignal<string | NgpOverlayContent<T> | null>;
+    disabled: Signal<boolean>;
+    placement: Signal<NgpTooltipPlacement>;
+    offset: Signal<NgpOffset>;
+    showDelay: Signal<number>;
+    hideDelay: Signal<number>;
+    flip: Signal<NgpFlip>;
+    shift: Signal<NgpShift>;
+    container: Signal<string | HTMLElement | null>;
+    showOnOverflow: Signal<boolean>;
+    anchor: Signal<HTMLElement | null>;
+    context: Signal<T | undefined>;
+    useTextContent: Signal<boolean>;
+    trackPosition: Signal<boolean>;
+    position: Signal<NgpPosition | null>;
+    scrollBehavior: Signal<"reposition" | "close">;
+    cooldown: Signal<number>;
+    hoverableContent: Signal<boolean>;
+    overlay: WritableSignal<NgpOverlay<string | T> | null>;
+    tooltipId: WritableSignal<string | undefined>;
+    open: Signal<boolean>;
+    hasOverflow: Signal<boolean>;
+    contentHovered: WritableSignal<boolean>;
+    hoverBridgePolygon: WritableSignal<TooltipHoverBridgePoint[] | null>;
+    show: () => void;
+    hide: () => void;
+    setTooltipId: (id: string) => void;
+    onTooltipHoverStart: () => void;
+    onTooltipHoverEnd: () => void;
+    destroy: () => void;
+};
+declare const provideTooltipTriggerState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+declare function injectTooltipTriggerState<T>(options?: StateInjectionOptions): Signal<NgpTooltipTriggerState<T>>;
+type NgpTooltipPlacement = 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'top-end' | 'right-start' | 'right-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end';
+
+type TooltipInput<T> = NgpOverlayContent<T> | string | null | undefined;
+/**
+ * Apply the `ngpTooltipTrigger` directive to an element that triggers the tooltip to show.
+ */
+declare class NgpTooltipTrigger<T = null> implements OnDestroy {
+    /**
+     * Access the global tooltip configuration.
+     */
+    private readonly config;
+    /**
+     * Access the tooltip template ref.
+     */
+    readonly tooltip: _angular_core.InputSignalWithTransform<string | NgpOverlayContent<T> | null, TooltipInput<T>>;
+    /**
+     * Define if the trigger should be disabled. This will prevent the tooltip from being shown or hidden from interactions.
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Define the placement of the tooltip relative to the trigger.
+     * @default 'top'
+     */
+    readonly placement: _angular_core.InputSignal<NgpTooltipPlacement>;
+    /**
+     * Define the offset of the tooltip relative to the trigger.
+     * Can be a number (applies to mainAxis) or an object with mainAxis, crossAxis, and alignmentAxis.
+     * @default 0
+     */
+    readonly offset: _angular_core.InputSignalWithTransform<NgpOffset, NgpOffsetInput>;
+    /**
+     * Define the delay before the tooltip is displayed.
+     * @default 500
+     */
+    readonly showDelay: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Define the delay before the tooltip is hidden.
+     * @default 0
+     */
+    readonly hideDelay: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Define whether the tooltip should flip when there is not enough space for the tooltip.
+     * Can be a boolean to enable/disable, or an object with padding and fallbackPlacements options.
+     * @default true
+     */
+    readonly flip: _angular_core.InputSignalWithTransform<NgpFlip, NgpFlipInput>;
+    /**
+     * Configure shift behavior to keep the tooltip in view.
+     * Can be a boolean to enable/disable, or an object with padding and limiter options.
+     * @default undefined (enabled by default in overlay)
+     */
+    readonly shift: _angular_core.InputSignalWithTransform<NgpShift, NgpShiftInput>;
+    /**
+     * Define the container in which the tooltip should be attached.
+     * @default document.body
+     */
+    readonly container: _angular_core.InputSignal<string | HTMLElement | null>;
+    /**
+     * Define whether the tooltip should only show when the trigger element overflows.
+     * @default false
+     */
+    readonly showOnOverflow: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Define an anchor element for positioning the tooltip.
+     * If provided, the tooltip will be positioned relative to this element instead of the trigger.
+     */
+    readonly anchor: _angular_core.InputSignal<HTMLElement | null>;
+    /**
+     * Provide context to the tooltip. This can be used to pass data to the tooltip content.
+     */
+    readonly context: _angular_core.InputSignal<T | undefined>;
+    /**
+     * Define whether to use the text content of the trigger element as the tooltip content.
+     * When enabled, the tooltip will display the text content of the trigger element.
+     * @default true
+     */
+    readonly useTextContent: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Define whether to track the trigger element position on every animation frame.
+     * Useful for moving elements like slider thumbs.
+     * @default false
+     */
+    readonly trackPosition: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Programmatic position for the tooltip. When provided, the tooltip
+     * will be positioned at these coordinates instead of the trigger element.
+     * Use with trackPosition="true" for smooth cursor following.
+     */
+    readonly position: _angular_core.InputSignal<NgpPosition | null>;
+    /**
+     * Defines how the tooltip behaves when the window is scrolled.
+     * @default 'reposition'
+     */
+    readonly scrollBehavior: _angular_core.InputSignal<"reposition" | "close">;
+    /**
+     * Define the cooldown duration in milliseconds.
+     * When moving from one tooltip to another within this duration,
+     * the showDelay is skipped for the new tooltip.
+     * @default 300
+     */
+    readonly cooldown: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Whether hovering tooltip content keeps the tooltip open.
+     * @default false
+     */
+    readonly hoverableContent: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly state: {
+        tooltip: _angular_core.WritableSignal<string | NgpOverlayContent<T> | null>;
+        disabled: _angular_core.Signal<boolean>;
+        placement: _angular_core.Signal<NgpTooltipPlacement>;
+        offset: _angular_core.Signal<NgpOffset>;
+        showDelay: _angular_core.Signal<number>;
+        hideDelay: _angular_core.Signal<number>;
+        flip: _angular_core.Signal<NgpFlip>;
+        shift: _angular_core.Signal<NgpShift>;
+        container: _angular_core.Signal<string | HTMLElement | null>;
+        showOnOverflow: _angular_core.Signal<boolean>;
+        anchor: _angular_core.Signal<HTMLElement | null>;
+        context: _angular_core.Signal<T | undefined>;
+        useTextContent: _angular_core.Signal<boolean>;
+        trackPosition: _angular_core.Signal<boolean>;
+        position: _angular_core.Signal<NgpPosition | null>;
+        scrollBehavior: _angular_core.Signal<"reposition" | "close">;
+        cooldown: _angular_core.Signal<number>;
+        hoverableContent: _angular_core.Signal<boolean>;
+        overlay: _angular_core.WritableSignal<ng_primitives_portal.NgpOverlay<string | T> | null>;
+        tooltipId: _angular_core.WritableSignal<string | undefined>;
+        open: _angular_core.Signal<boolean>;
+        hasOverflow: _angular_core.Signal<boolean>;
+        contentHovered: _angular_core.WritableSignal<boolean>;
+        hoverBridgePolygon: _angular_core.WritableSignal<TooltipHoverBridgePoint[] | null>;
+        show: () => void;
+        hide: () => void;
+        setTooltipId: (id: string) => void;
+        onTooltipHoverStart: () => void;
+        onTooltipHoverEnd: () => void;
+        destroy: () => void;
+    };
+    ngOnDestroy(): void;
+    /**
+     * Show the tooltip programmatically (skips cooldown so multiple tooltips can coexist).
+     */
+    show(): void;
+    /**
+     * Hide the tooltip.
+     */
+    hide(): void;
+    /**
+     * Called by tooltip content when pointer enters the tooltip.
+     * @internal
+     */
+    onTooltipHoverStart(): void;
+    /**
+     * Called by tooltip content when pointer leaves the tooltip.
+     * @internal
+     */
+    onTooltipHoverEnd(): void;
+    /**
+     * Set the tooltip id.
+     */
+    setTooltipId(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpTooltipTrigger<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpTooltipTrigger<any>, "[ngpTooltipTrigger]", ["ngpTooltipTrigger"], { "tooltip": { "alias": "ngpTooltipTrigger"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpTooltipTriggerDisabled"; "required": false; "isSignal": true; }; "placement": { "alias": "ngpTooltipTriggerPlacement"; "required": false; "isSignal": true; }; "offset": { "alias": "ngpTooltipTriggerOffset"; "required": false; "isSignal": true; }; "showDelay": { "alias": "ngpTooltipTriggerShowDelay"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "ngpTooltipTriggerHideDelay"; "required": false; "isSignal": true; }; "flip": { "alias": "ngpTooltipTriggerFlip"; "required": false; "isSignal": true; }; "shift": { "alias": "ngpTooltipTriggerShift"; "required": false; "isSignal": true; }; "container": { "alias": "ngpTooltipTriggerContainer"; "required": false; "isSignal": true; }; "showOnOverflow": { "alias": "ngpTooltipTriggerShowOnOverflow"; "required": false; "isSignal": true; }; "anchor": { "alias": "ngpTooltipTriggerAnchor"; "required": false; "isSignal": true; }; "context": { "alias": "ngpTooltipTriggerContext"; "required": false; "isSignal": true; }; "useTextContent": { "alias": "ngpTooltipTriggerUseTextContent"; "required": false; "isSignal": true; }; "trackPosition": { "alias": "ngpTooltipTriggerTrackPosition"; "required": false; "isSignal": true; }; "position": { "alias": "ngpTooltipTriggerPosition"; "required": false; "isSignal": true; }; "scrollBehavior": { "alias": "ngpTooltipTriggerScrollBehavior"; "required": false; "isSignal": true; }; "cooldown": { "alias": "ngpTooltipTriggerCooldown"; "required": false; "isSignal": true; }; "hoverableContent": { "alias": "ngpTooltipTriggerHoverableContent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Apply the `ngpTooltip` directive to an element that represents the tooltip. This typically would be a `div` inside an `ng-template`.
+ */
+declare class NgpTooltip {
+    /**
+     * The unique id of the tooltip.
+     */
+    readonly id: _angular_core.InputSignal<string>;
+    protected readonly state: {
+        elementRef: _angular_core.ElementRef<HTMLElement>;
+        id: _angular_core.WritableSignal<string>;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpTooltip, "[ngpTooltip]", ["ngpTooltip"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface NgpTooltipState {
+    /** Access the element's reference. */
+    readonly elementRef: ElementRef;
+    /** The unique id of the tooltip. */
+    readonly id: Signal<string>;
+}
+interface NgpTooltipProps {
+    /** The unique id of the tooltip. */
+    readonly id?: Signal<string>;
+}
+declare const NgpTooltipStateToken: _angular_core.InjectionToken<_angular_core.WritableSignal<{
+    elementRef: ElementRef<HTMLElement>;
+    id: _angular_core.WritableSignal<string>;
+}>>;
+declare const ngpTooltip: ({ id: _id }: NgpTooltipProps) => {
+    elementRef: ElementRef<HTMLElement>;
+    id: _angular_core.WritableSignal<string>;
+};
+declare const injectTooltipState: {
+    (): Signal<{
+        elementRef: ElementRef<HTMLElement>;
+        id: _angular_core.WritableSignal<string>;
+    }>;
+    (options: ng_primitives_state.StateInjectionOptions): Signal<{
+        elementRef: ElementRef<HTMLElement>;
+        id: _angular_core.WritableSignal<string>;
+    } | null>;
+    (options?: ng_primitives_state.StateInjectionOptions): Signal<{
+        elementRef: ElementRef<HTMLElement>;
+        id: _angular_core.WritableSignal<string>;
+    }> | Signal<{
+        elementRef: ElementRef<HTMLElement>;
+        id: _angular_core.WritableSignal<string>;
+    } | null>;
+};
+declare const provideTooltipState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+
+interface NgpTooltipTextContentState {
+    /** Access the component's context. */
+    readonly elementRef: ElementRef;
+    /** The string content to display. */
+    readonly content: Signal<unknown>;
+}
+interface NgpTooltipTextContentProps {
+}
+declare const NgpTooltipTextContentStateToken: _angular_core.InjectionToken<_angular_core.WritableSignal<{
+    elementRef: ElementRef<HTMLElement>;
+    content: Signal<unknown>;
+}>>;
+declare const ngpTooltipTextContent: ({}: NgpTooltipTextContentProps) => {
+    elementRef: ElementRef<HTMLElement>;
+    content: Signal<unknown>;
+};
+declare const injectTooltipTextContentState: {
+    (): Signal<{
+        elementRef: ElementRef<HTMLElement>;
+        content: Signal<unknown>;
+    }>;
+    (options: ng_primitives_state.StateInjectionOptions): Signal<{
+        elementRef: ElementRef<HTMLElement>;
+        content: Signal<unknown>;
+    } | null>;
+    (options?: ng_primitives_state.StateInjectionOptions): Signal<{
+        elementRef: ElementRef<HTMLElement>;
+        content: Signal<unknown>;
+    }> | Signal<{
+        elementRef: ElementRef<HTMLElement>;
+        content: Signal<unknown>;
+    } | null>;
+};
+declare const provideTooltipTextContentState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+
+export { NgpTooltip, NgpTooltipArrow, NgpTooltipArrowStateToken, NgpTooltipStateToken, NgpTooltipTextContentStateToken, NgpTooltipTrigger, NgpTooltipTriggerStateToken, injectTooltipArrowState, injectTooltipState, injectTooltipTextContentState, injectTooltipTriggerState, ngpTooltip, ngpTooltipArrow, ngpTooltipTextContent, ngpTooltipTrigger, provideTooltipArrowState, provideTooltipConfig, provideTooltipState, provideTooltipTextContentState, provideTooltipTriggerState };
+export type { NgpTooltipConfig, NgpTooltipPlacement, NgpTooltipProps, NgpTooltipState, NgpTooltipTextContentProps, NgpTooltipTextContentState, NgpTooltipTriggerProps, NgpTooltipTriggerState };