popover headless API

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

export declare const Popover: {
  Root: typeof Root;
  Trigger: import("react").ForwardRefExoticComponent<PopoverTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
  Content: import("react").ForwardRefExoticComponent<PopoverContentProps & import("react").RefAttributes<HTMLDivElement>>;
};

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

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

interface PopoverContextValue {
  readonly service: PopoverService;
  readonly connector: PopoverApi;
  readonly scope: PartScope;
}

interface PopoverOpenChangeDetail {
  readonly open: boolean;
  readonly reason: PopoverChangeReason;
}

interface PopoverRootProps {
  readonly open?: PopoverInput["open"];
  readonly defaultOpen?: PopoverInput["defaultOpen"];
  readonly side?: PopoverInput["side"];
  readonly align?: PopoverInput["align"];
  readonly onOpenChange?: (detail: PopoverOpenChangeDetail) => void;
  readonly children?: ReactNode;
}

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

declare function Root(props: PopoverRootProps): import("react").JSX.Element;

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

declare function usePopover(input: PopoverInput, options?: UsePopoverOptions): UsePopoverResult;

declare function usePopoverContext(partName: string): PopoverContextValue;

interface UsePopoverOptions {
  readonly onOpenChange?: (detail: PopoverOpenChangeDetail) => void;
}

interface UsePopoverResult {
  readonly service: PopoverService;
  readonly connector: PopoverApi;
  readonly scope: PartScope;
  readonly snapshot: PopoverSnapshot;
}

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

export declare const PopoverContent: 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 PopoverContextKey: InjectionKey<PopoverContextValue>;

interface PopoverContextValue {
  readonly service: PopoverService;
  readonly connector: PopoverApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<PopoverSnapshot>;
}

interface PopoverOpenChangeDetail {
  readonly open: boolean;
  readonly reason: PopoverChangeReason;
}

export declare const PopoverRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  open: {
    type: PropType<PopoverInput["open"]>;
    default: undefined;
  };
  defaultOpen: {
    type: PropType<PopoverInput["defaultOpen"]>;
    default: undefined;
  };
  side: {
    type: PropType<PopoverInput["side"]>;
    default: undefined;
  };
  align: {
    type: PropType<PopoverInput["align"]>;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  openChange: (_detail: PopoverOpenChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  open: {
    type: PropType<PopoverInput["open"]>;
    default: undefined;
  };
  defaultOpen: {
    type: PropType<PopoverInput["defaultOpen"]>;
    default: undefined;
  };
  side: {
    type: PropType<PopoverInput["side"]>;
    default: undefined;
  };
  align: {
    type: PropType<PopoverInput["align"]>;
    default: undefined;
  };
}>> & Readonly<{
  onOpenChange?: ((_detail: PopoverOpenChangeDetail) => any) | undefined;
}>, {
  open: boolean | undefined;
  defaultOpen: boolean | undefined;
  side: "bottom" | "top" | undefined;
  align: "end" | "start" | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const PopoverTrigger: 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 providePopoverContext(value: PopoverContextValue): void;

declare function usePopover(input: PopoverInput | (() => PopoverInput), options?: UsePopoverOptions): UsePopoverResult;

declare function usePopoverContext(partName: string): PopoverContextValue;

interface UsePopoverOptions {
  readonly onOpenChange?: (detail: PopoverOpenChangeDetail) => void;
}

interface UsePopoverResult {
  readonly service: PopoverService;
  readonly connector: PopoverApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<PopoverSnapshot>;
}

export declare function createPopoverStore(initialInput: PopoverInput, options?: CreatePopoverStoreOptions): PopoverStore;

export interface CreatePopoverStoreOptions {
    readonly onOpenChange?: (detail: PopoverOpenChangeDetail) => void;
    readonly onCommit?: () => void;
}

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

export declare const GR_POPOVER_DECLARATIONS: readonly [typeof GrPopoverRoot, typeof GrPopoverTrigger, typeof GrPopoverOpen, typeof GrPopoverContent];

export declare class GrPopoverContent extends PopoverPartBase {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<GrPopoverContent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrPopoverContent, "[grPopoverContent]", never, {}, {}, never, never, true, never>;
}

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

export declare class GrPopoverRoot implements OnDestroy {
    readonly open: import("@angular/core").InputSignal<boolean | undefined>;
    readonly defaultOpen: import("@angular/core").InputSignal<boolean | undefined>;
    readonly side: import("@angular/core").InputSignal<"bottom" | "top" | undefined>;
    readonly align: import("@angular/core").InputSignal<"start" | "end" | undefined>;
    readonly openChange: import("@angular/core").OutputEmitterRef<PopoverOpenChangeDetail>;
    private readonly injector;
    private lastSynced;
    private releaseManagers;
    readonly store: PopoverStore;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrPopoverRoot, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrPopoverRoot, "[grPopoverRoot]", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; }, never, never, true, never>;
}

export declare class GrPopoverTrigger extends PopoverPartBase {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<GrPopoverTrigger, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrPopoverTrigger, "[grPopoverTrigger]", never, {}, {}, never, never, true, never>;
}

export declare const POPOVER_STORE: InjectionToken<PopoverStore>;

export interface PopoverOpenChangeDetail {
    readonly open: boolean;
    readonly reason: PopoverChangeReason;
}

export interface PopoverStore {
    readonly service: PopoverService;
    readonly connector: PopoverApi;
    readonly scope: PartScope;
    readonly version: WritableSignal<number>;
    start(): void;
    stop(): void;
    sync(input: PopoverInput): void;
    bindOpenChange?(handler: (detail: import("./use-popover.js").PopoverOpenChangeDetail) => void): void;
}

export declare function providePopoverStore(): Provider;

export declare function createPopover(inputGetter: () => PopoverInput, options?: UsePopoverOptions): UsePopoverResult;

export declare const PopoverContent: LegacyComponentType;

export interface PopoverContextValue {
    readonly service: PopoverService;
    readonly connector: PopoverApi;
    readonly scope: PartScope;
    readonly version: () => number;
}

export interface PopoverOpenChangeDetail {
    readonly open: boolean;
    readonly reason: PopoverChangeReason;
}

export declare const PopoverRoot: LegacyComponentType;

export declare const PopoverTrigger: LegacyComponentType;

export declare function providePopoverContext(value: PopoverContextValue): void;

export declare function usePopoverContext(partName: string): PopoverContextValue;

export interface UsePopoverOptions {
    readonly onOpenChange?: (detail: PopoverOpenChangeDetail) => void;
}

export interface UsePopoverResult {
    readonly service: PopoverService;
    readonly connector: PopoverApi;
    readonly scope: PartScope;
    readonly version: () => number;
}

export declare function PopoverContent(props: PopoverContentProps): JSX.Element;

export interface PopoverContentProps extends JSX.HTMLAttributes<HTMLDivElement> {
    readonly as?: AsProp;
}

export declare const PopoverContext: import("solid-js").Context<PopoverContextValue | undefined>;

export interface PopoverContextValue {
    readonly service: PopoverService;
    readonly connector: PopoverApi;
    readonly scope: PartScope;
    readonly snapshot: Accessor<PopoverSnapshot>;
}