/**
 * Context shape for `<Dialog.Root>` — consumed by every dialog sub-part.
 *
 * Mirrors Base UI React's `DialogRootContext` (`packages/react/src/dialog/
 * root/DialogRootContext.ts`). The Solid port exposes every reactive field
 * as an `Accessor<T>` so consumers can subscribe without wrapping.
 *
 * Context uses the `createContext<T | null>(null)` + `== null` sentinel
 * pattern — `<Dialog.Root>` wraps the subtree and every part
 * reads through `useDialogRootContext()`, which throws if no provider is
 * present (unless `optional: true` is passed).
 */
import { type Accessor } from "solid-js";
import type { BaseUIChangeEventDetails, REASONS } from "../internals/change-event-details.js";
import type { InteractionType } from "../internals/floating-ui/components/floating-focus-manager.js";
import type { FloatingRootStore } from "../internals/floating-ui/components/floating-root-store.js";
import type { UseInteractionsReturn } from "../internals/floating-ui/hooks/use-interactions.js";
import type { MutableRef } from "../internals/floating-ui/types.js";
import type { TransitionStatus } from "../internals/use-transition-status/use-transition-status.js";
import type { DialogStore } from "./store/dialog-store.js";
/**
 * Modal kind for `<Dialog.Root>`:
 *
 * - `true` (default): focus-trap + scroll-lock + outside pointer block.
 * - `false`: none of the above (dialog is dismissable via the backdrop
 *   click path but keyboard focus isn't trapped).
 * - `"trap-focus"`: focus is trapped but scroll isn't locked and outside
 *   pointer interactions remain enabled.
 */
export type DialogModalKind = boolean | "trap-focus";
/** Change-event reason union for `<Dialog.Root>`. */
export type DialogRootChangeEventReason = typeof REASONS.triggerPress | typeof REASONS.outsidePress | typeof REASONS.escapeKey | typeof REASONS.closePress | typeof REASONS.focusOut | typeof REASONS.imperativeAction | typeof REASONS.none;
/**
 * `BaseUIChangeEventDetails` extended with the React Dialog-specific
 * `preventUnmountOnClose()` hook. When called from inside `onOpenChange`,
 * the dialog stays mounted after `open=false` — useful for consumers
 * controlling unmount timing through an external animation library.
 */
export type DialogRootChangeEventDetails = BaseUIChangeEventDetails<DialogRootChangeEventReason, {
    preventUnmountOnClose: () => void;
}>;
/**
 * Shared state surfaced on the dialog root context. Every field is a
 * signal/accessor except imperative writers.
 */
export interface DialogRootContextValue<Payload = unknown> {
    /** Reactive open flag. */
    open: Accessor<boolean>;
    /** Whether the dialog's DOM is mounted (open OR animating out). */
    mounted: Accessor<boolean>;
    /** Enter/exit transition status, or `undefined` when settled. */
    transitionStatus: Accessor<TransitionStatus>;
    /** Modal kind. */
    modal: Accessor<DialogModalKind>;
    /**
     * When true, outside-press dismissal is disabled (the dialog only
     * closes via Escape / Close / imperative).
     */
    disablePointerDismissal: Accessor<boolean>;
    /**
     * The ARIA role applied to the popup. `"dialog"` for `<Dialog.Root>`,
     * `"alertdialog"` for `<AlertDialog.Root>`. Currently fixed to
     * `"dialog"` for the dialog compound; `alert-dialog` will override.
     */
    role: Accessor<"dialog" | "alertdialog">;
    /** Whether the dialog has a parent dialog ancestor. */
    nested: Accessor<boolean>;
    /** Number of nested dialogs currently open underneath this root. */
    nestedOpenDialogCount: Accessor<number>;
    /** Number of nested drawers currently open underneath this root. */
    nestedOpenDrawerCount: Accessor<number>;
    /**
     * How the dialog was opened — reflects the interaction type captured
     * by `useOpenInteractionType`. Used by the popup to decide default
     * initial-focus behavior (touch → focus the popup element to avoid a
     * virtual keyboard flash).
     */
    openMethod: Accessor<InteractionType | null>;
    /** Title element id → consumed by popup's `aria-labelledby`. */
    titleId: Accessor<string | undefined>;
    setTitleId: (id: string | undefined) => void;
    /** Description element id → consumed by popup's `aria-describedby`. */
    descriptionId: Accessor<string | undefined>;
    setDescriptionId: (id: string | undefined) => void;
    /**
     * The shared `FloatingRootStore`. `useDismiss` / `useRole` write and
     * the popup / trigger read reactive signals off of it.
     */
    floatingRootContext: FloatingRootStore;
    /** Prop-getter bundle from `useInteractions([dismiss, role])`. */
    interactions: UseInteractionsReturn;
    /**
     * Imperative setOpen — used by trigger, close button, and the handle.
     */
    setOpen: (next: boolean, details: DialogRootChangeEventDetails) => void;
    /**
     * Popup ref slot written by `<Dialog.Popup>`. The root reads it for
     * `useOpenChangeComplete`'s unmount timing and outside-press checks.
     */
    popupRef: MutableRef<HTMLElement | null>;
    /** Backdrop ref slot, written by `<Dialog.Backdrop>`. */
    backdropRef: MutableRef<HTMLElement | null>;
    /** Internal backdrop ref slot, written by `<Dialog.Portal>`. */
    internalBackdropRef: MutableRef<HTMLElement | null>;
    /**
     * When `current` is `false`, `useDismiss`'s outside-press path is
     * suppressed. `<Drawer.SwipeArea>` flips it off during an active
     * swipe-open gesture so the release doesn't dismiss the drawer it
     * just opened.
     */
    outsidePressEnabledRef: MutableRef<boolean>;
    /** Popup element accessor (reactive). */
    popupElement: Accessor<HTMLElement | null>;
    setPopupElement: (el: HTMLElement | null) => void;
    /** Viewport element accessor (reactive). */
    viewportElement: Accessor<HTMLElement | null>;
    setViewportElement: (el: HTMLElement | null) => void;
    /** Active trigger element. */
    triggerElement: Accessor<HTMLElement | null>;
    setTriggerElement: (el: HTMLElement | null) => void;
    /** Active trigger id. */
    activeTriggerId: Accessor<string | null>;
    setActiveTriggerId: (id: string | null) => void;
    /** The dialog's store (handle registry + imperative wire). */
    store: DialogStore<Payload>;
    /** Payload written by the active trigger. */
    payload: Accessor<Payload | undefined>;
    setPayload: (payload: Payload | undefined) => void;
    /**
     * Parent-context callback invoked by a nested dialog/drawer when it
     * opens. The child passes its own nested counts (+1 for itself,
     * +(isDrawer ? 1 : 0) drawer delta). The receiving parent mirrors the
     * counts into its own `nestedOpenDialogCount` / `nestedOpenDrawerCount`
     * selectors so the parent's popup can flip `data-nested-dialog-open`
     * and `data-nested-drawer-open`. Mirrors React's `onNestedDialogOpen`
     * context callback.
     */
    onNestedDialogOpen: (dialogCount: number, drawerCount: number) => void;
    /**
     * Parent-context callback invoked when a nested dialog/drawer closes.
     * Resets the parent's `nestedOpenDialogCount` / `nestedOpenDrawerCount`
     * to zero. Mirrors React's `onNestedDialogClose`.
     */
    onNestedDialogClose: () => void;
}
/**
 * Context — `null` is the sentinel for "no provider". We don't use
 * `undefined` here.
 */
export declare const DialogRootContext: import("solid-js").Context<DialogRootContextValue<unknown> | null>;
/**
 * Read the current `<Dialog.Root>` context. Throws unless `optional` is
 * `true`. Mirrors Base UI React's `useDialogRootContext` overloads.
 */
export declare function useDialogRootContext(): DialogRootContextValue<unknown>;
export declare function useDialogRootContext(optional: true): DialogRootContextValue<unknown> | null;
/**
 * Drawer detection context. Set to `true` by `<Drawer.Root>` (not yet
 * ported), read here by `<Dialog.Root>` to decide whether to count this
 * dialog as a drawer for the nested-open bookkeeping. Ships now so the
 * counting paths compose cleanly when drawer lands later.
 */
export declare const IsDrawerContext: import("solid-js").Context<boolean>;
//# sourceMappingURL=dialog-root-context.d.ts.map