dialog headless API

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

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

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

export declare const Description: import("react").ForwardRefExoticComponent<DialogDescriptionProps & import("react").RefAttributes<HTMLParagraphElement>>;

export declare const Dialog: {
  Root: typeof Root;
  Trigger: import("react").ForwardRefExoticComponent<DialogTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
  Backdrop: import("react").ForwardRefExoticComponent<DialogBackdropProps & import("react").RefAttributes<HTMLDivElement>>;
  Positioner: import("react").ForwardRefExoticComponent<DialogPositionerProps & import("react").RefAttributes<HTMLDivElement>>;
  Content: import("react").ForwardRefExoticComponent<DialogContentProps & import("react").RefAttributes<HTMLDivElement>>;
  Title: import("react").ForwardRefExoticComponent<DialogTitleProps & import("react").RefAttributes<HTMLHeadingElement>>;
  Description: import("react").ForwardRefExoticComponent<DialogDescriptionProps & import("react").RefAttributes<HTMLParagraphElement>>;
  CloseTrigger: import("react").ForwardRefExoticComponent<DialogCloseTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
};

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

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

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

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

interface DialogContextValue {
  readonly service: DialogService;
  readonly connector: DialogApi;
  readonly scope: PartScope;
}

interface DialogDescriptionProps extends ComponentPropsWithoutRef<"p"> {
  readonly asChild?: boolean;
}

interface DialogOpenChangeDetail {
  readonly open: boolean;
  readonly reason: DialogChangeReason;
}

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

interface DialogRootProps {
  readonly open?: DialogInput["open"];
  readonly defaultOpen?: DialogInput["defaultOpen"];
  readonly dismissable?: DialogInput["dismissable"];
  readonly onOpenChange?: (detail: DialogOpenChangeDetail) => void;
  readonly children?: ReactNode;
}

interface DialogTitleProps extends ComponentPropsWithoutRef<"h2"> {
  readonly asChild?: boolean;
}

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

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

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

export declare const Title: import("react").ForwardRefExoticComponent<DialogTitleProps & import("react").RefAttributes<HTMLHeadingElement>>;

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

declare function useDialog(input: DialogInput, options?: UseDialogOptions): UseDialogResult;

declare function useDialogContext(partName: string): DialogContextValue;

interface UseDialogOptions {
  readonly onOpenChange?: (detail: DialogOpenChangeDetail) => void;
}

interface UseDialogResult {
  readonly service: DialogService;
  readonly connector: DialogApi;
  readonly scope: PartScope;
  readonly snapshot: DialogSnapshot;
}

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

export declare const DialogBackdrop: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => 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 DialogCloseTrigger: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => 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 DialogContent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => 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 DialogContextKey: InjectionKey<DialogContextValue>;

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

export declare const DialogDescription: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => 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>;

interface DialogOpenChangeDetail {
  readonly open: boolean;
  readonly reason: DialogChangeReason;
}

export declare const DialogPositioner: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => 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 DialogRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  open: {
    type: PropType<DialogInput["open"]>;
    default: undefined;
  };
  defaultOpen: {
    type: PropType<DialogInput["defaultOpen"]>;
    default: undefined;
  };
  dismissable: {
    type: PropType<DialogInput["dismissable"]>;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  openChange: (_detail: DialogOpenChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  open: {
    type: PropType<DialogInput["open"]>;
    default: undefined;
  };
  defaultOpen: {
    type: PropType<DialogInput["defaultOpen"]>;
    default: undefined;
  };
  dismissable: {
    type: PropType<DialogInput["dismissable"]>;
    default: undefined;
  };
}>> & Readonly<{
  onOpenChange?: ((_detail: DialogOpenChangeDetail) => any) | undefined;
}>, {
  open: boolean | undefined;
  defaultOpen: boolean | undefined;
  dismissable: boolean | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

export declare const DialogTitle: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => 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 DialogTrigger: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => 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 useDialog(input: DialogInput | (() => DialogInput), options?: UseDialogOptions): InternalUseDialogResult;

declare function useDialogContext(partName: string): DialogContextValue;

interface UseDialogOptions {
  readonly onOpenChange?: (detail: DialogOpenChangeDetail) => void;
}

interface UseDialogResult {
  readonly service: DialogService;
  readonly connector: DialogApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<DialogSnapshot>;
}

export declare function createDialogStore(initialInput: DialogInput, options?: CreateDialogStoreOptions): DialogStore;

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

export declare const DIALOG_PROJECTION_STORE: InjectionToken<DialogProjectionStore>;

export declare const DIALOG_STORE: InjectionToken<DialogStore>;

export interface DialogOpenChangeDetail {
    readonly open: boolean;
    readonly reason: DialogChangeReason;
}

export interface DialogProjectionStore {
    readonly scope: Pick<PartScope, "id" | "register">;
    readonly version: () => number;
    readonly connector: {
        titleProps(): PartProps;
        descriptionProps(): PartProps;
    };
}

export interface DialogStore {
    readonly service: DialogService;
    readonly connector: DialogApi;
    readonly scope: PartScope;
    /**
     * Bumped on every committed machine update. Effects that read the
     * connector's prop bags must read this signal first — inside the same
     * `effect()` — so Angular's reactivity re-runs the effect on every
     * committed change (the staleness bug class called out across every
     * other adapter).
     */
    readonly version: WritableSignal<number>;
    /** Starts the underlying service (idempotent) — call from the browser only. */
    start(): void;
    /** Stops the underlying service (idempotent). */
    stop(): void;
    /** Forwards a new committed input to the machine (no-op on the very first call). */
    sync(input: DialogInput): void;
}

export declare const GR_DIALOG_DECLARATIONS: readonly [typeof GrDialogRoot, typeof GrDialogTrigger, typeof GrDialogOpen, typeof GrDialogBackdrop, typeof GrDialogPositioner, typeof GrDialogContent, typeof GrDialogTitle, typeof GrDialogDescription, typeof GrDialogCloseTrigger];

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