hover-card headless API

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

export declare const HoverCard: {
  Root: import("react").ForwardRefExoticComponent<HoverCardRootProps & import("react").RefAttributes<HTMLDivElement>>;
  Trigger: import("react").ForwardRefExoticComponent<HoverCardTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
  Content: import("react").ForwardRefExoticComponent<HoverCardContentProps & import("react").RefAttributes<HTMLDivElement>>;
};

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

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

interface HoverCardContextValue {
  readonly service: HoverCardService;
  readonly connector: HoverCardApi;
  readonly scope: PartScope;
}

interface HoverCardOpenChangeDetail {
  readonly open: boolean;
  readonly reason: HoverCardChangeReason;
}

interface HoverCardRootProps extends Omit<ComponentPropsWithoutRef<"div">, "open" | "defaultValue"> {
  readonly asChild?: boolean;
  readonly open?: HoverCardInput["open"];
  readonly defaultOpen?: HoverCardInput["defaultOpen"];
  readonly openDelayMs?: HoverCardInput["openDelayMs"];
  readonly closeDelayMs?: HoverCardInput["closeDelayMs"];
  readonly side?: HoverCardInput["side"];
  readonly onOpenChange?: (detail: HoverCardOpenChangeDetail) => void;
  readonly scheduler?: UseHoverCardOptions["scheduler"];
  readonly children?: ReactNode;
}

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

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

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

declare function useHoverCard(input: HoverCardInput, options?: UseHoverCardOptions): UseHoverCardResult;

declare function useHoverCardContext(partName: string): HoverCardContextValue;

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

interface UseHoverCardResult {
  readonly service: HoverCardService;
  readonly connector: HoverCardApi;
  readonly scope: PartScope;
  readonly snapshot: HoverCardSnapshot;
}

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

export declare const HoverCardContent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}> | null, {}, {}, {}, 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 HoverCardContextKey: InjectionKey<HoverCardContextValue>;

interface HoverCardOpenChangeDetail {
  readonly open: boolean;
  readonly reason: HoverCardChangeReason;
}

export declare const HoverCardRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  open: {
    type: PropType<HoverCardInput["open"]>;
    default: undefined;
  };
  defaultOpen: {
    type: PropType<HoverCardInput["defaultOpen"]>;
    default: undefined;
  };
  openDelayMs: {
    type: PropType<HoverCardInput["openDelayMs"]>;
    default: undefined;
  };
  closeDelayMs: {
    type: PropType<HoverCardInput["closeDelayMs"]>;
    default: undefined;
  };
  side: {
    type: PropType<HoverCardInput["side"]>;
    default: undefined;
  };
  scheduler: {
    type: PropType<UseHoverCardOptions["scheduler"]>;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  openChange: (_detail: HoverCardOpenChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  open: {
    type: PropType<HoverCardInput["open"]>;
    default: undefined;
  };
  defaultOpen: {
    type: PropType<HoverCardInput["defaultOpen"]>;
    default: undefined;
  };
  openDelayMs: {
    type: PropType<HoverCardInput["openDelayMs"]>;
    default: undefined;
  };
  closeDelayMs: {
    type: PropType<HoverCardInput["closeDelayMs"]>;
    default: undefined;
  };
  side: {
    type: PropType<HoverCardInput["side"]>;
    default: undefined;
  };
  scheduler: {
    type: PropType<UseHoverCardOptions["scheduler"]>;
    default: undefined;
  };
}>> & Readonly<{
  onOpenChange?: ((_detail: HoverCardOpenChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  open: boolean | undefined;
  defaultOpen: boolean | undefined;
  openDelayMs: number | undefined;
  closeDelayMs: number | undefined;
  side: "bottom" | "top" | undefined;
  scheduler: import("@grassroot/statechart/scheduler").Scheduler | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const HoverCardTrigger: 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 useHoverCard(input: HoverCardInput | (() => HoverCardInput), options?: UseHoverCardOptions): UseHoverCardResult;

declare function useHoverCardContext(partName: string): HoverCardContextValue;

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

interface UseHoverCardResult {
  readonly service: HoverCardService;
  readonly connector: HoverCardApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<HoverCardSnapshot>;
}

export declare function createHoverCardStore(initialInput: HoverCardInput, options?: CreateHoverCardStoreOptions): HoverCardStore;

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

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

export declare const GR_HOVER_CARD_DECLARATIONS: readonly [];

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

export declare class GrHoverCardOpen implements OnDestroy {
    private readonly store;
    private readonly template;
    private readonly view;
    private rendered;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrHoverCardOpen, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrHoverCardOpen, "[grHoverCardOpen]", never, {}, {}, never, never, true, never>;
}

export declare class GrHoverCardRoot 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 side: import("@angular/core").InputSignal<"bottom" | "top" | undefined>;
    readonly openChange: import("@angular/core").OutputEmitterRef<HoverCardOpenChangeDetail>;
    private readonly element;
    private readonly injector;
    private readonly appRef;
    private readonly listeners;
    private last;
    readonly store: HoverCardStore;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrHoverCardRoot, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrHoverCardRoot, "gr-hover-card-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; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; }, never, ["*"], true, never>;
}

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

export declare const HOVER_CARD_STORE: InjectionToken<HoverCardStore>;

export interface HoverCardOpenChangeDetail {
    readonly open: boolean;
    readonly reason: HoverCardChangeReason;
}

export interface HoverCardStore {
    readonly service: HoverCardService;
    readonly connector: HoverCardApi;
    readonly scope: PartScope;
    readonly version: WritableSignal<number>;
    start(): void;
    stop(): void;
    sync(input: HoverCardInput): void;
    bindOpenChange(handler: (detail: import("./use-hover-card.js").HoverCardOpenChangeDetail) => void): void;
}

export declare function provideHoverCardStore(): Provider;

export declare function createHoverCard(inputGetter: () => HoverCardInput, options?: UseHoverCardOptions): UseHoverCardResult;

export declare const HoverCardContent: LegacyComponentType;

export interface HoverCardOpenChangeDetail {
    readonly open: boolean;
    readonly reason: HoverCardChangeReason;
}

export declare const HoverCardRoot: LegacyComponentType;

export declare const HoverCardTrigger: LegacyComponentType;

export declare function provideHoverCardContext(value: HoverCardContextValue): void;

export declare function useHoverCardContext(partName: string): HoverCardContextValue;

export interface UseHoverCardOptions {
    readonly onOpenChange?: (detail: HoverCardOpenChangeDetail) => void;
    readonly scheduler?: Scheduler;
}

export interface UseHoverCardResult {
    readonly service: HoverCardService;
    readonly connector: HoverCardApi;
    readonly scope: PartScope;
    readonly version: () => number;
}