tooltip headless API

export declare const Arrow: import("react").ForwardRefExoticComponent<TooltipArrowProps & import("react").RefAttributes<HTMLDivElement>>;

export declare const Content: import("react").ForwardRefExoticComponent<TooltipContentProps & import("react").RefAttributes<HTMLDivElement>>;

export declare const Root: import("react").ForwardRefExoticComponent<TooltipRootProps & import("react").RefAttributes<HTMLDivElement>>;

export declare const Tooltip: {
  Root: import("react").ForwardRefExoticComponent<TooltipRootProps & import("react").RefAttributes<HTMLDivElement>>;
  Trigger: import("react").ForwardRefExoticComponent<TooltipTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
  Content: import("react").ForwardRefExoticComponent<TooltipContentProps & import("react").RefAttributes<HTMLDivElement>>;
  Arrow: import("react").ForwardRefExoticComponent<TooltipArrowProps & import("react").RefAttributes<HTMLDivElement>>;
};

interface TooltipArrowProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
}

interface TooltipContentProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
}

export declare const TooltipContext: import("react").Context<TooltipContextValue | null>;

interface TooltipContextValue {
  readonly service: TooltipService;
  readonly connector: TooltipApi;
  readonly scope: PartScope;
}

interface TooltipOpenChangeDetail {
  readonly open: boolean;
  readonly reason: TooltipChangeReason;
}

interface TooltipRootProps extends Omit<ComponentPropsWithoutRef<"div">, "open" | "defaultValue"> {
  readonly asChild?: boolean;
  readonly open?: TooltipInput["open"];
  readonly defaultOpen?: TooltipInput["defaultOpen"];
  readonly openDelayMs?: TooltipInput["openDelayMs"];
  readonly closeDelayMs?: TooltipInput["closeDelayMs"];
  readonly disabled?: TooltipInput["disabled"];
  readonly side?: TooltipInput["side"];
  readonly onOpenChange?: (detail: TooltipOpenChangeDetail) => void;
  /** Native (production) by default; inject a virtual scheduler for tests. */
  readonly scheduler?: UseTooltipOptions["scheduler"];
  readonly children?: ReactNode;
}

interface TooltipTriggerProps extends Omit<ComponentPropsWithoutRef<"button">, "type"> {
  readonly asChild?: boolean;
}

export declare const Trigger: import("react").ForwardRefExoticComponent<TooltipTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;

declare function useServiceVersion<S extends Service<any, any, any, any, any, any>>(service: S): ReturnType<S["getSnapshot"]>;

declare function useTooltip(input: TooltipInput$1, options?: UseTooltipOptions): UseTooltipResult;

declare function useTooltipContext(partName: string): TooltipContextValue;

interface UseTooltipOptions {
  readonly onOpenChange?: (detail: TooltipOpenChangeDetail) => void;
  /** Native (production) by default; inject a virtual scheduler for tests. */
  readonly scheduler?: Scheduler;
}

interface UseTooltipResult {
  readonly service: TooltipService;
  readonly connector: TooltipApi;
  readonly scope: PartScope;
  readonly snapshot: TooltipSnapshot;
}

export declare const TooltipArrow: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const TooltipContent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const TooltipContextKey: InjectionKey<TooltipContextValue>;

interface TooltipContextValue {
  readonly service: TooltipService;
  readonly connector: TooltipApi;
  readonly scope: PartScope;
  /** Bumped on every committed machine update; parts read `.value` to establish a reactive dependency. */
  readonly snapshot: ShallowRef<TooltipSnapshot>;
}

interface TooltipOpenChangeDetail {
  readonly open: boolean;
  readonly reason: TooltipChangeReason;
}

export declare const TooltipRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  open: {
    type: PropType<TooltipInput["open"]>;
    default: undefined;
  };
  defaultOpen: {
    type: PropType<TooltipInput["defaultOpen"]>;
    default: undefined;
  };
  openDelayMs: {
    type: PropType<TooltipInput["openDelayMs"]>;
    default: undefined;
  };
  closeDelayMs: {
    type: PropType<TooltipInput["closeDelayMs"]>;
    default: undefined;
  };
  disabled: {
    type: PropType<TooltipInput["disabled"]>;
    default: undefined;
  };
  side: {
    type: PropType<TooltipInput["side"]>;
    default: undefined;
  };
  /** Native (production) by default; inject a virtual scheduler for tests. */
  scheduler: {
    type: PropType<UseTooltipOptions["scheduler"]>;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  openChange: (_detail: TooltipOpenChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  open: {
    type: PropType<TooltipInput["open"]>;
    default: undefined;
  };
  defaultOpen: {
    type: PropType<TooltipInput["defaultOpen"]>;
    default: undefined;
  };
  openDelayMs: {
    type: PropType<TooltipInput["openDelayMs"]>;
    default: undefined;
  };
  closeDelayMs: {
    type: PropType<TooltipInput["closeDelayMs"]>;
    default: undefined;
  };
  disabled: {
    type: PropType<TooltipInput["disabled"]>;
    default: undefined;
  };
  side: {
    type: PropType<TooltipInput["side"]>;
    default: undefined;
  };
  /** Native (production) by default; inject a virtual scheduler for tests. */
  scheduler: {
    type: PropType<UseTooltipOptions["scheduler"]>;
    default: undefined;
  };
}>> & Readonly<{
  onOpenChange?: ((_detail: TooltipOpenChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  open: boolean | undefined;
  defaultOpen: boolean | undefined;
  openDelayMs: number | undefined;
  closeDelayMs: number | undefined;
  disabled: boolean | undefined;
  side: "bottom" | "top" | undefined;
  scheduler: import("@grassroot/statechart/scheduler").Scheduler | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const TooltipTrigger: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

declare function useTooltip(input: TooltipInput | (() => TooltipInput), options?: UseTooltipOptions): UseTooltipResult;

declare function useTooltipContext(partName: string): TooltipContextValue;

interface UseTooltipOptions {
  readonly onOpenChange?: (detail: TooltipOpenChangeDetail) => void;
  readonly scheduler?: Scheduler;
}

interface UseTooltipResult {
  readonly service: TooltipService;
  readonly connector: TooltipApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<TooltipSnapshot>;
}

export declare function createReentrantSafeTick(appRef: ApplicationRef): () => void;

export declare function createTooltipStore(initialInput: TooltipInput, options?: CreateTooltipStoreOptions): TooltipStore;

export interface CreateTooltipStoreOptions {
    readonly onOpenChange?: (detail: TooltipOpenChangeDetail) => void;
    readonly onCommit?: () => void;
    readonly scheduler?: Scheduler;
}

export declare const GR_TOOLTIP_DECLARATIONS: readonly [typeof GrTooltipRoot, typeof GrTooltipTrigger, typeof GrTooltipContent, typeof GrTooltipArrow];

export declare class GrTooltipArrow implements OnDestroy {
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrTooltipArrow, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrTooltipArrow, "[grTooltipArrow]", never, {}, {}, never, never, true, never>;
}

export declare class GrTooltipContent implements OnDestroy {
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrTooltipContent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrTooltipContent, "[grTooltipContent]", never, {}, {}, never, never, true, never>;
}

export declare class GrTooltipRoot implements OnDestroy {
    readonly open: import("@angular/core").InputSignal<boolean | undefined>;
    readonly defaultOpen: import("@angular/core").InputSignal<boolean | undefined>;
    readonly openDelayMs: import("@angular/core").InputSignal<number | undefined>;
    readonly closeDelayMs: import("@angular/core").InputSignal<number | undefined>;
    readonly disabled: import("@angular/core").InputSignal<boolean | undefined>;
    readonly side: import("@angular/core").InputSignal<"bottom" | "top" | undefined>;
    readonly openChange: import("@angular/core").OutputEmitterRef<TooltipOpenChangeDetail>;
    private readonly elementRef;
    private readonly injector;
    private readonly listeners;
    private lastSynced;
    readonly store: TooltipStore;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrTooltipRoot, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrTooltipRoot, "gr-tooltip-root", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "openDelayMs": { "alias": "openDelayMs"; "required": false; "isSignal": true; }; "closeDelayMs": { "alias": "closeDelayMs"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; }, never, ["*"], true, never>;
}

export declare class GrTooltipTrigger implements OnDestroy {
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrTooltipTrigger, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrTooltipTrigger, "[grTooltipTrigger]", never, {}, {}, never, never, true, never>;
}

export declare function provideTooltipStore(): Provider;

export declare const TOOLTIP_STORE: InjectionToken<TooltipStore>;

export interface TooltipOpenChangeDetail {
    readonly open: boolean;
    readonly reason: TooltipChangeReason;
}