@forte-ui/react 1.0.0-alpha.1

package/dist/components/dialog/Dialog.d.ts

@@ -0,0 +1,567 @@
+import { Dialog as BaseDialog, DialogRootProps as BaseDialogRootProps, DialogTriggerProps as BaseDialogTriggerProps, DialogPopupProps as BaseDialogPopupProps, DialogPortalProps as BaseDialogPortalProps, DialogTitleProps as BaseDialogTitleProps, DialogDescriptionProps as BaseDialogDescriptionProps, DialogCloseProps as BaseDialogCloseProps } from '@base-ui/react/dialog';
+import { AlertDialog as BaseAlertDialog, AlertDialogRootProps as BaseAlertDialogRootProps, AlertDialogTriggerProps as BaseAlertDialogTriggerProps } from '@base-ui/react/alert-dialog';
+import { ButtonTone } from '../button';
+import * as React from "react";
+export type DialogSize = "sm" | "md" | "lg" | "fullscreen";
+export type DialogFooterAlign = "start" | "center" | "end" | "between";
+/**
+ * Props for `Dialog.Root`. Every Base UI `Dialog.Root` prop is forwarded
+ * unchanged — `open`, `defaultOpen`, `onOpenChange`, `onOpenChangeComplete`,
+ * `modal`, `disablePointerDismissal`, `actionsRef`, `handle`, `triggerId`,
+ * `defaultTriggerId`.
+ *
+ * `Root` renders no DOM element, so it accepts no `className`, `style` or
+ * `ref`. Style the popup instead.
+ */
+export type DialogRootProps<Payload = unknown> = BaseDialogRootProps<Payload>;
+/**
+ * Groups all parts of a dialog and owns its open state.
+ *
+ * Renders no DOM element of its own.
+ */
+export declare function DialogRoot<Payload>(props: DialogRootProps<Payload>): React.JSX.Element;
+/**
+ * Props for `AlertDialog.Root`.
+ *
+ * Identical to `DialogRootProps` minus `modal` and `disablePointerDismissal`:
+ * an alert dialog is *always* modal and never dismisses on an outside press,
+ * because it interrupts the user to ask a question that has to be answered.
+ */
+export type AlertDialogRootProps<Payload = unknown> = BaseAlertDialogRootProps<Payload>;
+/**
+ * Groups all parts of an alert dialog — a modal, non-dismissible dialog that
+ * requires an explicit response.
+ *
+ * Renders no DOM element of its own.
+ */
+export declare function AlertDialogRoot<Payload>(props: AlertDialogRootProps<Payload>): React.JSX.Element;
+export interface DialogTriggerProps<Payload = unknown> extends Omit<BaseDialogTriggerProps<Payload>, "className"> {
+    /**
+     * Additional class name(s). Applied after the internal styles so consumer
+     * utilities (e.g. Tailwind) win without needing `!important`.
+     */
+    className?: string;
+}
+/**
+ * `React.forwardRef` erases generics, so the exported value is re-typed with
+ * a generic call signature — the same shape Base UI itself exports — to keep
+ * `payload` and `handle` inferring together.
+ */
+interface DialogTriggerComponent {
+    <Payload>(props: DialogTriggerProps<Payload>): React.JSX.Element;
+}
+/**
+ * A button that opens the dialog.
+ *
+ * Renders a `<button>`. Pass `render={<Button />}` to compose it with a
+ * styled button — the trigger's own neutral styling steps aside when `render`
+ * is present, so the two never fight over the cascade.
+ */
+export declare const DialogTrigger: DialogTriggerComponent;
+export interface AlertDialogTriggerProps<Payload = unknown> extends Omit<BaseAlertDialogTriggerProps<Payload>, "className"> {
+    /**
+     * Additional class name(s). Applied after the internal styles so consumer
+     * utilities (e.g. Tailwind) win without needing `!important`.
+     */
+    className?: string;
+}
+interface AlertDialogTriggerComponent {
+    <Payload>(props: AlertDialogTriggerProps<Payload>): React.JSX.Element;
+}
+/**
+ * A button that opens the alert dialog.
+ *
+ * Renders a `<button>`. Identical to `Dialog.Trigger` except that it accepts
+ * an `AlertDialog` handle.
+ */
+export declare const AlertDialogTrigger: AlertDialogTriggerComponent;
+export interface DialogPopupProps extends Omit<BaseDialogPopupProps, "className"> {
+    /**
+     * Maximum width of the popup. `"fullscreen"` drops the radius and the
+     * viewport padding and lets the surface fill the screen, which is the
+     * usual mobile treatment for a long form.
+     * @default "md"
+     */
+    size?: DialogSize;
+    /**
+     * Keep the portal — and therefore the popup — in the DOM while the dialog
+     * is closed. Needed when something inside must stay mounted (an iframe, a
+     * media element, uncommitted form state).
+     * @default false
+     */
+    keepMounted?: boolean;
+    /**
+     * Element the portal renders into. Defaults to `document.body`; set it when
+     * the dialog must live inside a specific stacking or shadow root.
+     */
+    container?: BaseDialogPortalProps["container"];
+    /**
+     * Render the scrim behind the popup. Turn it off for a non-modal dialog
+     * that should leave the page visibly usable.
+     * @default true
+     */
+    backdrop?: boolean;
+    /**
+     * Render the backdrop even when this dialog is nested inside another one.
+     * Base UI suppresses nested backdrops by default — the parent dims itself
+     * through `[data-nested-dialog-open]` instead — so only set this when a
+     * nested dialog genuinely needs its own scrim.
+     * @default false
+     */
+    forceBackdrop?: boolean;
+    /**
+     * Additional class name(s) for the backdrop element. The popup's own
+     * `className` cannot reach it, since the backdrop is a sibling rendered
+     * inside this component.
+     */
+    backdropClassName?: string;
+    /**
+     * Additional class name(s) for the scrollable viewport that positions the
+     * popup. Use it to change alignment (e.g. pin the dialog to the top), or to
+     * re-point `--forte-dialog-z-index` — it defaults to 40, one band under the
+     * anchored popups, so a `Select` or `Tooltip` inside a dialog stays above
+     * it. The backdrop reads `--forte-dialog-backdrop-z-index` (39) from
+     * `backdropClassName`, since it is the viewport's sibling.
+     */
+    viewportClassName?: string;
+    /**
+     * Additional class name(s) for the popup itself. Applied after the internal
+     * styles so consumer utilities (e.g. Tailwind) win without needing
+     * `!important`.
+     */
+    className?: string;
+}
+/**
+ * The dialog surface, together with the three wrappers it always needs:
+ * `Portal` → `Backdrop` + `Viewport` → `Popup`. Collapsing them into one
+ * component keeps the common case to a single element while leaving every
+ * Base UI `Popup` prop (`initialFocus`, `finalFocus`, `render`, …) available.
+ *
+ * `Title`, `Description` and `Close` must be rendered *inside* this component:
+ * that is what auto-wires `aria-labelledby` / `aria-describedby`, and a close
+ * button outside the popup is unreachable to touch screen-reader users.
+ *
+ * The same component serves `AlertDialog` — Base UI's alert dialog re-exports
+ * these exact parts.
+ */
+export declare const DialogPopup: React.ForwardRefExoticComponent<Omit<DialogPopupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export interface DialogSurfaceProps extends Omit<React.ComponentPropsWithoutRef<"div">, "className"> {
+    /**
+     * Additional class name(s). Applied after the internal styles so consumer
+     * utilities (e.g. Tailwind) win without needing `!important`.
+     */
+    className?: string;
+}
+/**
+ * The visible panel, for dialogs that also carry chrome *outside* it — a close
+ * button floating clear of the corner, a caption under the sheet, pager arrows
+ * beside it.
+ *
+ * Use it and `Dialog.Popup` stops painting: the popup keeps the sizing, the
+ * focus trap and the enter/exit gesture but turns into a transparent container,
+ * and this element becomes the surface. Everything stays inside `Dialog.Popup`
+ * and therefore inside the tab order and the accessibility tree — which is the
+ * whole point, since in a modal dialog anything outside the popup is inert.
+ *
+ * There is no prop to pair it with. The stylesheet asks `.popup:has(> .surface)`,
+ * so the popup switches on the presence of this element and the two cannot
+ * disagree. Keep it a *direct* child of `Dialog.Popup`.
+ *
+ * A plain `<div>`, not a Base UI part — the primitive has no such anatomy, and
+ * Base UI's own example for this pattern uses a bare div too.
+ */
+export declare const DialogSurface: React.ForwardRefExoticComponent<DialogSurfaceProps & React.RefAttributes<HTMLDivElement>>;
+export interface DialogTitleProps extends Omit<BaseDialogTitleProps, "className"> {
+    /**
+     * Additional class name(s). Applied after the internal styles so consumer
+     * utilities (e.g. Tailwind) win without needing `!important`.
+     */
+    className?: string;
+}
+/**
+ * The dialog's accessible name.
+ *
+ * Renders an `<h2>`. Inside `Dialog.Popup` it is wired up as the popup's
+ * `aria-labelledby` automatically; every dialog should have one.
+ */
+export declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogTitleProps, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+export interface DialogDescriptionProps extends Omit<BaseDialogDescriptionProps, "className"> {
+    /**
+     * Additional class name(s). Applied after the internal styles so consumer
+     * utilities (e.g. Tailwind) win without needing `!important`.
+     */
+    className?: string;
+}
+/**
+ * A short explanation of what the dialog is for.
+ *
+ * Renders a `<p>`. Inside `Dialog.Popup` it becomes the popup's
+ * `aria-describedby`, so it is announced after the title.
+ */
+export declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogDescriptionProps, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export interface DialogCloseProps extends Omit<BaseDialogCloseProps, "className"> {
+    /**
+     * Render as a square button sized for a single icon — the corner "×"
+     * treatment. Enforces the 24px minimum hit target from WCAG SC 2.5.8.
+     * Always pair with `aria-label`, since there is no text to announce.
+     * @default false
+     */
+    iconOnly?: boolean;
+    /**
+     * Additional class name(s). Applied after the internal styles so consumer
+     * utilities (e.g. Tailwind) win without needing `!important`.
+     */
+    className?: string;
+}
+/**
+ * A button that closes the dialog.
+ *
+ * Renders a `<button>`. Keep it inside `Dialog.Popup`: in a modal dialog the
+ * rest of the page is inert, and a touch screen-reader user has no other way
+ * out. Pass `render={<Button />}` to compose it with a styled button — the
+ * close button's own neutral styling steps aside when `render` is present.
+ */
+export declare const DialogClose: React.ForwardRefExoticComponent<Omit<DialogCloseProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export interface DialogFooterProps extends Omit<React.ComponentPropsWithoutRef<"div">, "className"> {
+    /**
+     * How the actions are distributed along the footer. `"between"` is the
+     * pattern for a destructive action pushed away from the safe one.
+     * @default "end"
+     */
+    align?: DialogFooterAlign;
+    /**
+     * Additional class name(s). Applied after the internal styles so consumer
+     * utilities (e.g. Tailwind) win without needing `!important`.
+     */
+    className?: string;
+}
+/**
+ * The action row at the bottom of a dialog.
+ *
+ * A plain `<div>` — not a Base UI part — that supplies the standard spacing
+ * and alignment for the confirm/cancel buttons. In a `size="fullscreen"`
+ * dialog it sinks to the bottom edge.
+ */
+export declare const DialogFooter: React.ForwardRefExoticComponent<DialogFooterProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * The fields every built-in dialog understands.
+ *
+ * `title` and `description` are the two fields a toast takes, and they mean
+ * the same thing here — which is why `dialog.confirm("Delete this?")` becomes
+ * the *title* rather than the body. The title is the dialog's accessible name,
+ * and a dialog without one is announced as just "dialog".
+ */
+export interface DialogMessageOptions {
+    /** The question or the statement, and the dialog's accessible name. */
+    title?: React.ReactNode;
+    /** A second line under it, and the dialog's accessible description. */
+    description?: React.ReactNode;
+    /**
+     * Maximum width of the popup. These dialogs hold a sentence and two
+     * buttons, so they start narrower than a composed one.
+     * @default "sm"
+     */
+    size?: DialogSize;
+    /**
+     * Tone of the button that answers the dialog. Reach for `"danger"` whenever
+     * the answer destroys something — it also moves the footer to
+     * `align="between"`, which pushes the safe button away from it.
+     * @default "primary"
+     */
+    tone?: ButtonTone;
+    /**
+     * Additional class name(s) for the popup — the place to set a
+     * `--forte-dialog-*` knob for one call.
+     */
+    className?: string;
+}
+/** Options for `dialog.alert()`. */
+export interface DialogAlertOptions extends DialogMessageOptions {
+    /**
+     * Label of the single acknowledging button.
+     * @default the provider's `labels.ok`, "OK"
+     */
+    okLabel?: React.ReactNode;
+}
+/** Options for `dialog.confirm()`. */
+export interface DialogConfirmOptions extends DialogMessageOptions {
+    /**
+     * Label of the button that resolves the promise with `true`.
+     * @default the provider's `labels.confirm`, "Confirm"
+     */
+    confirmLabel?: React.ReactNode;
+    /**
+     * Label of the button that resolves it with `false`.
+     * @default the provider's `labels.cancel`, "Cancel"
+     */
+    cancelLabel?: React.ReactNode;
+    /**
+     * How the two buttons are distributed along the footer.
+     * @default `"between"` when `tone` is `"danger"`, `"end"` otherwise
+     */
+    align?: DialogFooterAlign;
+}
+/** Options for `dialog.confirmWithInput()`. */
+export interface DialogConfirmWithInputOptions extends DialogConfirmOptions {
+    /**
+     * The exact string the user has to type before the confirm button enables.
+     * Surrounding whitespace is ignored, since a pasted value often carries a
+     * trailing space and that is not a different answer.
+     */
+    confirmValue: string;
+    /**
+     * Label above the input.
+     * @default the provider's `labels.confirmInput`, "Type <confirmValue> to confirm"
+     */
+    inputLabel?: React.ReactNode;
+    /**
+     * Placeholder inside the input.
+     * @default `confirmValue`
+     */
+    placeholder?: string;
+    /**
+     * Whether the typed value has to match `confirmValue`'s case. Leave it on
+     * for a destructive action: an answer that has to be typed exactly is the
+     * whole point of the pattern.
+     * @default true
+     */
+    caseSensitive?: boolean;
+}
+/**
+ * What a component rendered by `dialog.show()` receives.
+ *
+ * It renders the *contents* of the dialog — normally one `Dialog.Popup` — and
+ * not the root. The provider owns the root, which is what lets it stack the
+ * dialog on whatever is already open, hold the entry in the tree until the
+ * exit transition ends, and guarantee that the promise settles even when the
+ * dialog is dismissed by Escape rather than answered by a button.
+ */
+export interface CustomDialogProps<Payload = void, Result = void> {
+    /** The second argument `dialog.show()` was called with. */
+    payload: Payload;
+    /**
+     * Answers the dialog: resolves the promise with `result` and starts the exit
+     * transition. Stable for the life of the dialog, and safe to call twice —
+     * the first answer is the one that is kept.
+     */
+    close: (result: Result) => void;
+    /**
+     * Dismisses the dialog: resolves the promise with `dismissValue` — the same
+     * thing Escape and an outside press do. It exists because `close()` demands
+     * a `Result`, and a cancel button has none to give.
+     */
+    dismiss: () => void;
+}
+/** A component that can be handed to `dialog.show()`. */
+export type CustomDialogComponent<Payload = void, Result = void> = React.ComponentType<CustomDialogProps<Payload, Result>>;
+/** Options for `dialog.show()`. */
+export interface DialogShowOptions<Result = void> {
+    /**
+     * Render an `AlertDialog.Root` instead of a `Dialog.Root`: always modal,
+     * never dismissed by a press outside it. Use it when the dialog asks a
+     * question that has to be answered.
+     * @default false
+     */
+    alert?: boolean;
+    /**
+     * What the promise resolves to when the dialog is dismissed — Escape, an
+     * outside press, the provider unmounting — rather than answered through
+     * `close()`.
+     * @default undefined
+     */
+    dismissValue?: Result;
+}
+/**
+ * The copy the built-in dialogs put on screen that the call site does not
+ * supply. Override it on `Dialog.Provider` — that is the translation seam, and
+ * it is the reason `confirm()` can take a message and nothing else.
+ */
+export interface DialogLabels {
+    /** The single button on `alert()`. */
+    ok: React.ReactNode;
+    /** The affirmative button on `confirm()` and `confirmWithInput()`. */
+    confirm: React.ReactNode;
+    /** The dismissing button on both. */
+    cancel: React.ReactNode;
+    /** The label above the input on `confirmWithInput()`. */
+    confirmInput: (confirmValue: string) => React.ReactNode;
+}
+/**
+ * The dialog API — what `useDialog()` returns, and what
+ * `Dialog.createManager()` gives you outside React.
+ *
+ * Every method resolves when the user answers or dismisses the dialog, not
+ * when it finishes animating away: an `await dialog.confirm()` continues the
+ * moment the decision is made.
+ */
+export interface DialogApi {
+    /**
+     * Shows a message that has to be acknowledged. Resolves when it is.
+     *
+     * A bare message becomes the `title`, which is the dialog's accessible name.
+     */
+    alert: (options: React.ReactNode | DialogAlertOptions) => Promise<void>;
+    /**
+     * Asks a yes-or-no question. Resolves to `true` when the user confirms, and
+     * to `false` for every other way out — Cancel, Escape, the provider
+     * unmounting.
+     */
+    confirm: (options: React.ReactNode | DialogConfirmOptions) => Promise<boolean>;
+    /**
+     * Asks a yes-or-no question whose confirm button stays disabled until the
+     * user types `confirmValue`. The pattern for a delete that cannot be undone.
+     */
+    confirmWithInput: (options: DialogConfirmWithInputOptions) => Promise<boolean>;
+    /**
+     * Shows a component of your own and resolves with whatever it passes to
+     * `close()`. Resolves to `dismissValue` — `undefined` unless you say
+     * otherwise — when it is dismissed instead.
+     */
+    show: <Payload, Result = void>(Component: CustomDialogComponent<Payload, Result>, payload: Payload, options?: DialogShowOptions<Result>) => Promise<Result | undefined>;
+    /** Dismisses the topmost dialog, exactly as Escape does. */
+    close: () => void;
+    /** Dismisses every dialog on the stack. */
+    closeAll: () => void;
+}
+/**
+ * A manager from `Dialog.createManager()`. Same methods as `useDialog()`,
+ * usable from anywhere.
+ */
+export type DialogManager = DialogApi;
+/**
+ * Creates a dialog manager that works outside React.
+ *
+ * ```ts
+ * // dialogs.ts
+ * export const dialogs = Dialog.createManager();
+ *
+ * // anywhere — an API client, a router guard, a store
+ * if (await dialogs.confirm("Discard your draft?")) discard();
+ *
+ * // app root
+ * <Dialog.Provider manager={dialogs}>…</Dialog.Provider>
+ * ```
+ *
+ * Pass the manager itself, not something inside it — unlike `Toast.Provider`,
+ * which has a Base UI manager underneath to hand over.
+ *
+ * A dialog opened before a provider has mounted is *queued* rather than
+ * dropped, because a dropped one would leave its promise pending for the life
+ * of the page. It appears as soon as a provider mounts. If none ever does, the
+ * `await` never returns — so mount the provider at the root, once.
+ */
+export declare function createDialogManager(): DialogManager;
+export interface DialogProviderProps {
+    /** The part of the app that can open dialogs. */
+    children?: React.ReactNode;
+    /**
+     * A manager from `Dialog.createManager()`. Pass one and the provider drives
+     * that manager's stack instead of its own, which is what lets code outside
+     * React open a dialog. `useDialog()` reaches the same stack either way.
+     */
+    manager?: DialogManager;
+    /**
+     * Overrides for the built-in button labels — the only copy `alert()`,
+     * `confirm()` and `confirmWithInput()` put on screen that the call site does
+     * not supply. Set it once here instead of passing `okLabel` and
+     * `cancelLabel` to every call; this is the translation seam.
+     */
+    labels?: Partial<DialogLabels>;
+}
+/**
+ * Enables `useDialog()` underneath it, and renders whatever is opened.
+ *
+ * ```tsx
+ * <Dialog.Provider>
+ *   <App />
+ * </Dialog.Provider>
+ * ```
+ *
+ * Mount it once, above everything that might ask a question. It renders no DOM
+ * element of its own and every dialog is portalled to `<body>`, so where it
+ * sits in the tree does not matter beyond that.
+ *
+ * The stack it renders is *nested*: a dialog opened while another is on screen
+ * becomes that dialog's child, which is what makes the parent step back and
+ * dim instead of being covered by a second backdrop.
+ */
+export declare function DialogProvider({ children, manager, labels, }: DialogProviderProps): React.JSX.Element;
+/**
+ * Opens dialogs from inside a component, and waits for the answer.
+ *
+ * ```tsx
+ * const dialog = useDialog();
+ *
+ * if (await dialog.confirm("Delete this draft?")) {
+ *   await deleteDraft();
+ * }
+ * ```
+ *
+ * Must be called under a `Dialog.Provider`.
+ *
+ * The object and every method on it keep the same identity for the life of the
+ * provider, so both the object and one pulled out by destructuring are safe in
+ * a dependency array.
+ */
+export declare function useDialog(): DialogApi;
+/**
+ * A modal surface built on Base UI's `Dialog`.
+ *
+ * ```tsx
+ * <Dialog.Root>
+ *   <Dialog.Trigger render={<Button />}>Edit profile</Dialog.Trigger>
+ *   <Dialog.Popup size="sm">
+ *     <Dialog.Title>Edit profile</Dialog.Title>
+ *     <Dialog.Description>Change your display name.</Dialog.Description>
+ *     <Dialog.Footer>
+ *       <Dialog.Close render={<Button variant="soft" tone="neutral" />}>
+ *         Cancel
+ *       </Dialog.Close>
+ *       <Dialog.Close render={<Button />}>Save</Dialog.Close>
+ *     </Dialog.Footer>
+ *   </Dialog.Popup>
+ * </Dialog.Root>
+ * ```
+ *
+ * `Dialog.Provider` and `useDialog()` are the other way to reach the same
+ * surface — a dialog opened by a call and awaited for its answer, for the
+ * questions that have no button on screen to hang a `Root` off.
+ */
+export declare const Dialog: {
+    Root: typeof DialogRoot;
+    Trigger: DialogTriggerComponent;
+    Popup: React.ForwardRefExoticComponent<Omit<DialogPopupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Surface: React.ForwardRefExoticComponent<DialogSurfaceProps & React.RefAttributes<HTMLDivElement>>;
+    Title: React.ForwardRefExoticComponent<Omit<DialogTitleProps, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+    Description: React.ForwardRefExoticComponent<Omit<DialogDescriptionProps, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+    Close: React.ForwardRefExoticComponent<Omit<DialogCloseProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    Footer: React.ForwardRefExoticComponent<DialogFooterProps & React.RefAttributes<HTMLDivElement>>;
+    /** Enables `useDialog()` underneath it, and renders what it opens. */
+    Provider: typeof DialogProvider;
+    /** Creates a handle that connects a `Dialog.Root` to detached triggers. */
+    createHandle: typeof BaseDialog.createHandle;
+    /** Creates a dialog manager usable outside React. */
+    createManager: typeof createDialogManager;
+};
+/**
+ * An always-modal dialog that interrupts the user and requires an answer —
+ * confirming a delete, discarding unsaved work.
+ *
+ * Shares every part and every style with `Dialog`; only `Root` and `Trigger`
+ * differ. There is deliberately no `modal` or `disablePointerDismissal` prop:
+ * an alert dialog traps focus, locks page scroll, and cannot be dismissed by
+ * clicking outside it. Give it at least one `AlertDialog.Close`.
+ */
+export declare const AlertDialog: {
+    Root: typeof AlertDialogRoot;
+    Trigger: AlertDialogTriggerComponent;
+    Popup: React.ForwardRefExoticComponent<Omit<DialogPopupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Surface: React.ForwardRefExoticComponent<DialogSurfaceProps & React.RefAttributes<HTMLDivElement>>;
+    Title: React.ForwardRefExoticComponent<Omit<DialogTitleProps, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+    Description: React.ForwardRefExoticComponent<Omit<DialogDescriptionProps, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+    Close: React.ForwardRefExoticComponent<Omit<DialogCloseProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    Footer: React.ForwardRefExoticComponent<DialogFooterProps & React.RefAttributes<HTMLDivElement>>;
+    /** Creates a handle that connects an `AlertDialog.Root` to detached triggers. */
+    createHandle: typeof BaseAlertDialog.createHandle;
+};
+export {};

package/dist/components/dialog/Dialog.js

@@ -0,0 +1,3 @@
+"use client";
+import { a as e, c as t, d as n, f as r, h as i, i as a, l as o, m as s, n as c, o as l, p as u, r as d, s as f, t as p, u as m } from "../../Dialog-_n8FpFs5.js";
+export { p as AlertDialog, c as AlertDialogRoot, d as AlertDialogTrigger, a as Dialog, e as DialogClose, l as DialogDescription, f as DialogFooter, t as DialogPopup, o as DialogProvider, m as DialogRoot, n as DialogSurface, r as DialogTitle, u as DialogTrigger, s as createDialogManager, i as useDialog };

package/dist/components/dialog/index.d.ts

@@ -0,0 +1,2 @@
+export { Dialog, AlertDialog, useDialog, DialogProvider, createDialogManager, } from './Dialog';
+export type { DialogSize, DialogFooterAlign, DialogRootProps, DialogTriggerProps, DialogPopupProps, DialogSurfaceProps, DialogTitleProps, DialogDescriptionProps, DialogCloseProps, DialogFooterProps, AlertDialogRootProps, AlertDialogTriggerProps, DialogProviderProps, DialogApi, DialogManager, DialogLabels, DialogMessageOptions, DialogAlertOptions, DialogConfirmOptions, DialogConfirmWithInputOptions, DialogShowOptions, CustomDialogProps, CustomDialogComponent, } from './Dialog';

package/dist/components/dialog/index.js

@@ -0,0 +1,2 @@
+import { h as e, i as t, l as n, m as r, t as i } from "../../Dialog-_n8FpFs5.js";
+export { i as AlertDialog, t as Dialog, n as DialogProvider, r as createDialogManager, e as useDialog };