/**
 * Shared behavioral machinery for Popover and DropdownMenu.
 * @module react/components/ui/anchored-surface
 */
import * as React from "react";
import { type PolymorphicButtonAttributes } from "./slot.js";
import { type DisclosureOptions } from "./disclosure.js";
/** Context value shared between an anchored skin's Root and its parts. */
export interface AnchoredState {
    open: boolean;
    setOpen: (open: boolean) => void;
    anchorRef: React.RefObject<HTMLElement | null>;
    anchorElement: HTMLElement | null;
    setAnchorElement: React.Dispatch<React.SetStateAction<HTMLElement | null>>;
    triggerRef: React.RefObject<HTMLElement | null>;
    defaultTriggerId: string;
    defaultContentId: string;
    triggerId: string;
    contentId: string;
    setTriggerId: React.Dispatch<React.SetStateAction<string>>;
    setContentId: React.Dispatch<React.SetStateAction<string>>;
}
/**
 * Backward-compatible public props for an anchored trigger.
 *
 * Keep this as a broad interface so existing wrapper interfaces, conditional
 * `asChild` values, and button-shaped prop spreads remain source-compatible.
 * Skin-level overloads add precise element refs for literal slotted calls.
 */
export interface AnchoredTriggerPublicProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
    asChild?: boolean;
    ref?: React.Ref<HTMLButtonElement>;
}
/** Slotted-element props for an anchored trigger. */
export type AnchoredSlottedTriggerProps<T extends HTMLElement = HTMLElement> = Omit<PolymorphicButtonAttributes<T>, "children" | "ref" | "type"> & {
    asChild: true;
    children: React.ReactElement;
    /** Apply disabled semantics across native and non-native slotted controls. */
    disabled?: boolean;
    /** Applied only when `children` is an intrinsic `<button>`; opaque buttons own `type`. */
    type?: T extends HTMLButtonElement ? React.ButtonHTMLAttributes<HTMLButtonElement>["type"] : never;
    ref?: React.Ref<T>;
};
/** Props for `AnchoredTrigger` (returned by the factory). */
export type AnchoredTriggerProps<T extends HTMLElement = HTMLElement> = (AnchoredTriggerPublicProps | AnchoredSlottedTriggerProps<T>) & {
    /** `aria-haspopup` value -- `"dialog"` for Popover, `"menu"` for DropdownMenu. */
    haspopup: NonNullable<React.AriaAttributes["aria-haspopup"]>;
};
/** Props for `AnchoredContent` (returned by the factory). */
export interface AnchoredContentProps extends React.HTMLAttributes<HTMLDivElement> {
    align?: "start" | "end";
    /** Internal focus target used by Popover and DropdownMenu skins. */
    initialFocus?: true | string;
    /** Consumer ref for the rendered floating surface. */
    ref?: React.Ref<HTMLDivElement>;
}
/**
 * Creates a fresh context instance plus the AnchoredRoot, AnchoredTrigger, and
 * AnchoredContent parts -- all bound to that context.
 *
 * Each skin (Popover, DropdownMenu) calls this ONCE at module scope so their
 * contexts are distinct objects. This prevents cross-binding when one skin is
 * nested inside the other or inside a modal skin: a DropdownMenuItem close
 * call only affects the DropdownMenu whose context is in scope, never a
 * Popover above it in the tree.
 */
export declare function createAnchoredSurfaceParts(): {
    Context: any;
    AnchoredRoot: ({ children, open, defaultOpen, onOpenChange }: DisclosureOptions & {
        children: React.ReactNode;
    }) => React.ReactElement;
    AnchoredTrigger: <T extends HTMLElement = HTMLElement>({ children, asChild, disabled, id, onClick, haspopup, ref, type, ...props }: AnchoredTriggerProps<T>) => React.ReactElement;
    AnchoredContent: ({ children, className, align, id, initialFocus, ref, tabIndex, "aria-labelledby": labelledBy, ...props }: AnchoredContentProps) => React.ReactElement | null;
};
//# sourceMappingURL=anchored-surface.d.ts.map