alert-dialog headless API

export declare const AlertDialog: {
  Root: typeof Root;
  Trigger: import("react").ForwardRefExoticComponent<AlertDialogTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
  Backdrop: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
    readonly asChild?: boolean;
  } & import("react").RefAttributes<HTMLDivElement>>;
  Positioner: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
    readonly asChild?: boolean;
  } & import("react").RefAttributes<HTMLDivElement>>;
  Content: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
    readonly asChild?: boolean;
  } & import("react").RefAttributes<HTMLDivElement>>;
  Title: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & {
    readonly asChild?: boolean;
  } & import("react").RefAttributes<HTMLHeadingElement>>;
  Description: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & {
    readonly asChild?: boolean;
  } & import("react").RefAttributes<HTMLParagraphElement>>;
  CloseTrigger: import("react").ForwardRefExoticComponent<AlertDialogTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
};

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

interface AlertDialogOpenChangeDetail {
  readonly open: boolean;
  readonly reason: AlertDialogChangeReason;
}

interface AlertDialogRootProps extends Pick<AlertDialogInput, "open" | "defaultOpen" | "dismissable"> {
  readonly onOpenChange?: (detail: {
    open: boolean;
    reason: string;
  }) => void;
  readonly children?: ReactNode;
}

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

export declare const Backdrop: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
  readonly asChild?: boolean;
} & import("react").RefAttributes<HTMLDivElement>>;

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

export declare const Content: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
  readonly asChild?: boolean;
} & import("react").RefAttributes<HTMLDivElement>>;

export declare const Description: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & {
  readonly asChild?: boolean;
} & import("react").RefAttributes<HTMLParagraphElement>>;

export declare const Positioner: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
  readonly asChild?: boolean;
} & import("react").RefAttributes<HTMLDivElement>>;

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

export declare const Title: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & {
  readonly asChild?: boolean;
} & import("react").RefAttributes<HTMLHeadingElement>>;

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

declare function useAlertDialog(input: AlertDialogInput, options?: UseAlertDialogOptions): UseAlertDialogResult;

declare function useAlertDialogContext(part: string): AlertDialogContextValue;

interface UseAlertDialogOptions {
  readonly onOpenChange?: (detail: AlertDialogOpenChangeDetail) => void;
}

interface UseAlertDialogResult {
  readonly service: AlertDialogService;
  readonly connector: AlertDialogApi;
  readonly scope: PartScope;
  readonly snapshot: AlertDialogSnapshot;
}

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

export declare const AlertDialogBackdrop: 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 AlertDialogCloseTrigger: 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 AlertDialogContent: 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 AlertDialogContextKey: InjectionKey<AlertDialogContextValue>;

interface AlertDialogContextValue {
  readonly service: AlertDialogService;
  readonly connector: AlertDialogApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<AlertDialogSnapshot>;
}

export declare const AlertDialogDescription: 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 AlertDialogOpenChangeDetail {
  readonly open: boolean;
  readonly reason: AlertDialogChangeReason;
}

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

export declare const AlertDialogTitle: 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 AlertDialogTrigger: 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>;

declare function useAlertDialog(input: AlertDialogInput | (() => AlertDialogInput), options?: UseAlertDialogOptions): UseAlertDialogResult;

declare function useAlertDialogContext(partName: string): AlertDialogContextValue;

interface UseAlertDialogOptions {
  readonly onOpenChange?: (detail: AlertDialogOpenChangeDetail) => void;
}

interface UseAlertDialogResult {
  readonly service: AlertDialogService;
  readonly connector: AlertDialogApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<AlertDialogSnapshot>;
  readonly hasMounted: ShallowRef<boolean>;
}

export declare const ALERT_DIALOG_STORE: InjectionToken<AlertDialogStore>;

export interface AlertDialogOpenChangeDetail {
    readonly open: boolean;
    readonly reason: AlertDialogChangeReason;
}

export interface AlertDialogStore {
    readonly service: AlertDialogService;
    readonly connector: AlertDialogApi;
    readonly scope: PartScope;
    readonly version: WritableSignal<number>;
    start(): void;
    stop(): void;
    sync(input: AlertDialogInput): void;
    bindOpenChange?(handler: (detail: {
        open: boolean;
        reason: AlertDialogChangeReason;
    }) => void): void;
}

export declare function createAlertDialogStore(initialInput: AlertDialogInput, options?: CreateAlertDialogStoreOptions): AlertDialogStore;

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

export declare const DIALOG_PROJECTION_STORE: InjectionToken<DialogProjectionStore>;

export declare const GR_ALERT_DIALOG_DECLARATIONS: readonly [typeof GrAlertDialogRoot, typeof GrAlertDialogTrigger, typeof GrAlertDialogOpen, typeof GrAlertDialogBackdrop, typeof GrAlertDialogPositioner, typeof GrAlertDialogContent, typeof GrAlertDialogTitle, typeof GrAlertDialogDescription, typeof GrAlertDialogCloseTrigger];

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

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

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

export declare class GrAlertDialogDescription extends AlertDialogPartBase {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAlertDialogDescription, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrAlertDialogDescription, "[grAlertDialogDescription], [grassrootDialogDescription]", never, {}, {}, never, never, true, never>;
}

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

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

export declare class GrAlertDialogRoot implements OnDestroy {
    readonly open: import("@angular/core").InputSignal<boolean | undefined>;
    readonly defaultOpen: import("@angular/core").InputSignal<boolean | undefined>;
    readonly dismissable: import("@angular/core").InputSignal<boolean | undefined>;
    readonly openChange: import("@angular/core").OutputEmitterRef<AlertDialogOpenChangeDetail>;
    private readonly injector;
    private last;
    private release?;
    private registrationTicked;
    readonly store: AlertDialogStore;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrAlertDialogRoot, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrAlertDialogRoot, "[grAlertDialogRoot]", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "dismissable": { "alias": "dismissable"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; }, never, never, true, never>;
}