@wix/site-ui 1.30.0 → 1.31.0

package/dist/Dialog/index.d.ts

@@ -1,47 +1,1384 @@
-import { Dialog as Dialog_2 } from '@base-ui/react/dialog';
-import { DialogBackdropProps } from '@base-ui/react/dialog';
-import { DialogCloseProps } from '@base-ui/react/dialog';
-import { DialogDescriptionProps } from '@base-ui/react/dialog';
-import { DialogPopupProps } from '@base-ui/react/dialog';
-import { DialogPortalProps } from '@base-ui/react/dialog';
-import { DialogTitleProps } from '@base-ui/react/dialog';
-import { DialogViewportProps } from '@base-ui/react/dialog';
+import { DialogBackdropProps as DialogBackdropProps_2 } from '@base-ui/react/dialog';
+import { DialogCloseProps as DialogCloseProps_2 } from '@base-ui/react/dialog';
+import { DialogDescriptionProps as DialogDescriptionProps_2 } from '@base-ui/react/dialog';
+import { DialogPopupProps as DialogPopupProps_2 } from '@base-ui/react/dialog';
+import { DialogPortalProps as DialogPortalProps_2 } from '@base-ui/react/dialog';
+import { DialogTitleProps as DialogTitleProps_2 } from '@base-ui/react/dialog';
+import { DialogViewportProps as DialogViewportProps_2 } from '@base-ui/react/dialog';
+import { FloatingRootContext as FloatingRootContext_2 } from '../../floating-ui-react/index.js';
+import { FloatingRootStore as FloatingRootStore_2 } from '../../floating-ui-react/components/FloatingRootStore.js';
+import { HTMLProps as HTMLProps_2 } from '../../index.js';
+import { InteractionType } from '@base-ui/utils/useEnhancedClickHandler';
 import { JSX as JSX_2 } from 'react/jsx-runtime';
 import * as React_2 from 'react';
+import { ReactStore } from '@base-ui/utils/store';
+import { TransitionStatus as TransitionStatus_2 } from '../../internals/useTransitionStatus.js';
+import type { UseFloatingReturn } from '@floating-ui/react-dom';
+import type { VirtualElement } from '@floating-ui/react-dom';
+
+declare type BaseUIChangeEventDetail<Reason extends string, CustomProperties extends object> = {
+    /**
+     * The reason for the event.
+     */
+    reason: Reason;
+    /**
+     * The native event associated with the custom event.
+     */
+    event: ReasonToEvent<Reason>;
+    /**
+     * Cancels Base UI from handling the event.
+     */
+    cancel: () => void;
+    /**
+     * Allows the event to propagate in cases where Base UI will stop the propagation.
+     */
+    allowPropagation: () => void;
+    /**
+     * Indicates whether the event has been canceled.
+     */
+    isCanceled: boolean;
+    /**
+     * Indicates whether the event is allowed to propagate.
+     */
+    isPropagationAllowed: boolean;
+    /**
+     * The element that triggered the event, if applicable.
+     */
+    trigger: Element | undefined;
+} & CustomProperties;
+
+/**
+ * Details of custom change events emitted by Base UI components.
+ */
+declare type BaseUIChangeEventDetails<Reason extends string, CustomProperties extends object = {}> = Reason extends string ? BaseUIChangeEventDetail<Reason, CustomProperties> & {} : never;
+
+/**
+ * Props shared by all Base UI components.
+ * Contains `className` (string or callback taking the component's state as an argument) and `render` (function to customize rendering).
+ */
+declare type BaseUIComponentProps<ElementType extends React_2.ElementType, State, RenderFunctionProps = HTMLProps> = Omit<WithBaseUIEvent<React_2.ComponentPropsWithRef<ElementType>>, 'className' | 'color' | 'defaultValue' | 'defaultChecked' | 'style'> & {
+    /**
+     * CSS class applied to the element, or a function that
+     * returns a class based on the component's state.
+     */
+    className?: string | ((state: State) => string | undefined) | undefined;
+    /**
+     * Allows you to replace the component's HTML element
+     * with a different tag, or compose it with another component.
+     *
+     * Accepts a `ReactElement` or a function that returns the element to render.
+     */
+    render?: React_2.ReactElement | ComponentRenderFn<RenderFunctionProps, State> | undefined;
+    /**
+     * Style applied to the element, or a function that
+     * returns a style object based on the component's state.
+     */
+    style?: React_2.CSSProperties | ((state: State) => React_2.CSSProperties | undefined) | undefined;
+};
+
+declare type BaseUIEvent<E extends React_2.SyntheticEvent<Element, Event>> = E & {
+    preventBaseUIHandler: () => void;
+    readonly baseUIHandlerPrevented?: boolean | undefined;
+};
+
+declare const cancelOpen: "cancel-open";
+
+declare const chipRemovePress: "chip-remove-press";
+
+declare const clearPress: "clear-press";
+
+declare const closePress: "close-press";
+
+declare const closeWatcher: "close-watcher";
+
+/**
+ * Shape of the render prop: a function that takes props to be spread on the element and component's state and returns a React element.
+ *
+ * @template Props Props to be spread on the rendered element.
+ * @template State Component's internal state.
+ */
+declare type ComponentRenderFn<Props, State> = (props: Props, state: State) => React_2.ReactElement<unknown>;
+
+declare type Context = PopupStoreContext<DialogRoot.ChangeEventDetails> & {
+    readonly popupRef: React_2.RefObject<HTMLElement | null>;
+    readonly backdropRef: React_2.RefObject<HTMLDivElement | null>;
+    readonly internalBackdropRef: React_2.RefObject<HTMLDivElement | null>;
+    readonly outsidePressEnabledRef: React_2.MutableRefObject<boolean>;
+    readonly onNestedDialogOpen?: ((dialogCount: number, drawerCount: number) => void) | undefined;
+    readonly onNestedDialogClose?: (() => void) | undefined;
+};
+
+declare interface ContextData {
+    openEvent?: Event | undefined;
+    floatingContext?: FloatingContext | undefined;
+    [key: string]: any;
+}
+
+/**
+ * Creates a new handle to connect a Dialog.Root with detached Dialog.Trigger components.
+ */
+declare function createDialogHandle<Payload>(): DialogHandle<Payload>;
+
+declare const decrementPress: "decrement-press";
 
 export declare const Dialog: {
-    Backdrop: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DialogBackdropProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Backdrop: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DialogBackdropProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Close: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DialogCloseProps, "ref"> & React_2.RefAttributes<HTMLButtonElement>, "ref">, "className"> & {
+    Close: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DialogCloseProps_2, "ref"> & React_2.RefAttributes<HTMLButtonElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLButtonElement>>;
-    Description: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DialogDescriptionProps, "ref"> & React_2.RefAttributes<HTMLParagraphElement>, "ref">, "className"> & {
+    Description: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DialogDescriptionProps_2, "ref"> & React_2.RefAttributes<HTMLParagraphElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLParagraphElement>>;
-    Popup: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DialogPopupProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Popup: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DialogPopupProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Title: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DialogTitleProps, "ref"> & React_2.RefAttributes<HTMLHeadingElement>, "ref">, "className"> & {
+    Title: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DialogTitleProps_2, "ref"> & React_2.RefAttributes<HTMLHeadingElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLHeadingElement>>;
-    Viewport: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DialogViewportProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Viewport: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DialogViewportProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
     Root: typeof Dialog_2.Root;
     Trigger: typeof Trigger;
-    Portal: React_2.ForwardRefExoticComponent<Omit<DialogPortalProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+    Portal: React_2.ForwardRefExoticComponent<Omit<DialogPortalProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
     Handle: typeof Dialog_2.Handle;
     createHandle: typeof Dialog_2.createHandle;
 };
 
+export declare namespace Dialog_2 {
+    export {
+        DialogBackdrop as Backdrop,
+        DialogClose as Close,
+        DialogDescription as Description,
+        DialogPopup as Popup,
+        DialogPortal as Portal,
+        DialogRoot as Root,
+        DialogViewport as Viewport,
+        DialogTitle as Title,
+        DialogTrigger as Trigger,
+        createDialogHandle as createHandle,
+        DialogHandle as Handle
+    }
+}
+
+/**
+ * An overlay displayed beneath the popup.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)
+ */
+export declare const DialogBackdrop: React_2.ForwardRefExoticComponent<Omit<DialogBackdropProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace DialogBackdrop {
+    export type Props = DialogBackdropProps;
+    export type State = DialogBackdropState;
+}
+
+export declare interface DialogBackdropProps extends BaseUIComponentProps<'div', DialogBackdropState> {
+    /**
+     * Whether the backdrop is forced to render even when nested.
+     * @default false
+     */
+    forceRender?: boolean | undefined;
+}
+
+export declare interface DialogBackdropState {
+    /**
+     * Whether the dialog is currently open.
+     */
+    open: boolean;
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+}
+
+/**
+ * A button that closes the dialog.
+ * Renders a `<button>` element.
+ *
+ * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)
+ */
+export declare const DialogClose: React_2.ForwardRefExoticComponent<Omit<DialogCloseProps, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare namespace DialogClose {
+    export type Props = DialogCloseProps;
+    export type State = DialogCloseState;
+}
+
+export declare interface DialogCloseProps extends NativeButtonProps, BaseUIComponentProps<'button', DialogCloseState> {}
+
+export declare interface DialogCloseState {
+    /**
+     * Whether the button is currently disabled.
+     */
+    disabled: boolean;
+}
+
+/**
+ * A paragraph with additional information about the dialog.
+ * Renders a `<p>` element.
+ *
+ * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)
+ */
+export declare const DialogDescription: React_2.ForwardRefExoticComponent<Omit<DialogDescriptionProps, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;
+
+export declare namespace DialogDescription {
+    export type Props = DialogDescriptionProps;
+    export type State = DialogDescriptionState;
+}
+
+export declare interface DialogDescriptionProps extends BaseUIComponentProps<'p', DialogDescriptionState> {}
+
+export declare interface DialogDescriptionState {}
+
+/**
+ * A handle to control a Dialog imperatively and to associate detached triggers with it.
+ */
+declare class DialogHandle<Payload> {
+    /**
+     * Internal store holding the dialog state.
+     * @internal
+     */
+    readonly store: DialogStore<Payload>;
+    constructor(store?: DialogStore<Payload>);
+    /**
+     * Opens the dialog and associates it with the trigger with the given id.
+     * The trigger, if provided, must be a matching Trigger component with this handle passed as a prop.
+     *
+     * This method should only be called in an event handler or an effect (not during rendering).
+     *
+     * @param triggerId ID of the trigger to associate with the dialog. If null, the dialog will open without a trigger association.
+     */
+    open(triggerId: string | null): void;
+    /**
+     * Opens the dialog and sets the payload.
+     * Does not associate the dialog with any trigger.
+     *
+     * @param payload Payload to set when opening the dialog.
+     */
+    openWithPayload(payload: Payload): void;
+    /**
+     * Closes the dialog.
+     */
+    close(): void;
+    /**
+     * Indicates whether the dialog is currently open.
+     */
+    get isOpen(): boolean;
+}
+
+/**
+ * A container for the dialog contents.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)
+ */
+export declare const DialogPopup: React_2.ForwardRefExoticComponent<Omit<DialogPopupProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace DialogPopup {
+    export type Props = DialogPopupProps;
+    export type State = DialogPopupState;
+}
+
+export declare interface DialogPopupProps extends BaseUIComponentProps<'div', DialogPopupState> {
+    /**
+     * Determines the element to focus when the dialog is opened.
+     *
+     * - `false`: Do not move focus.
+     * - `true`: Move focus based on the default behavior (first tabbable element or popup).
+     * - `RefObject`: Move focus to the ref element.
+     * - `function`: Called with the interaction type (`mouse`, `touch`, `pen`, or `keyboard`).
+     *   Return an element to focus, `true` to use the default behavior, or `false`/`undefined` to do nothing.
+     */
+    initialFocus?: boolean | React_2.RefObject<HTMLElement | null> | ((openType: InteractionType) => boolean | HTMLElement | null | void) | undefined;
+    /**
+     * Determines the element to focus when the dialog is closed.
+     *
+     * - `false`: Do not move focus.
+     * - `true`: Move focus based on the default behavior (trigger or previously focused element).
+     * - `RefObject`: Move focus to the ref element.
+     * - `function`: Called with the interaction type (`mouse`, `touch`, `pen`, or `keyboard`).
+     *   Return an element to focus, `true` to use the default behavior, or `false`/`undefined` to do nothing.
+     */
+    finalFocus?: boolean | React_2.RefObject<HTMLElement | null> | ((closeType: InteractionType) => boolean | HTMLElement | null | void) | undefined;
+}
+
+export declare interface DialogPopupState {
+    /**
+     * Whether the dialog is currently open.
+     */
+    open: boolean;
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+    /**
+     * Whether the dialog is nested within a parent dialog.
+     */
+    nested: boolean;
+    /**
+     * Whether the dialog has nested dialogs open.
+     */
+    nestedDialogOpen: boolean;
+}
+
+/**
+ * A portal element that moves the popup to a different part of the DOM.
+ * By default, the portal element is appended to `<body>`.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)
+ */
+export declare const DialogPortal: React_2.ForwardRefExoticComponent<Omit<DialogPortalProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace DialogPortal {
+    export type State = DialogPortalState;
+    export type Props = DialogPortalProps;
+}
+
+export declare interface DialogPortalProps extends FloatingPortal.Props<DialogPortalState> {
+    /**
+     * Whether to keep the portal mounted in the DOM while the popup is hidden.
+     * @default false
+     */
+    keepMounted?: boolean | undefined;
+    /**
+     * A parent element to render the portal element into.
+     */
+    container?: FloatingPortal.Props<DialogPortalState>['container'] | undefined;
+}
+
+export declare interface DialogPortalState {}
+
+/**
+ * Groups all parts of the dialog.
+ * Doesn't render its own HTML element.
+ *
+ * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)
+ */
+export declare function DialogRoot<Payload>(props: DialogRoot.Props<Payload>): JSX_2.Element;
+
+export declare namespace DialogRoot {
+    export type State = DialogRootState;
+    export type Props<Payload = unknown> = DialogRootProps<Payload>;
+    export type Actions = DialogRootActions;
+    export type ChangeEventReason = DialogRootChangeEventReason;
+    export type ChangeEventDetails = DialogRootChangeEventDetails;
+}
+
+export declare interface DialogRootActions {
+    unmount: () => void;
+    close: () => void;
+}
+
+export declare type DialogRootChangeEventDetails = BaseUIChangeEventDetails<DialogRoot.ChangeEventReason> & {
+    preventUnmountOnClose(): void;
+};
+
+export declare type DialogRootChangeEventReason = typeof REASONS.triggerPress | typeof REASONS.outsidePress | typeof REASONS.escapeKey | typeof REASONS.closePress | typeof REASONS.focusOut | typeof REASONS.imperativeAction | typeof REASONS.none;
+
+export declare interface DialogRootProps<Payload = unknown> {
+    /**
+     * Whether the dialog is currently open.
+     */
+    open?: boolean | undefined;
+    /**
+     * Whether the dialog is initially open.
+     *
+     * To render a controlled dialog, use the `open` prop instead.
+     * @default false
+     */
+    defaultOpen?: boolean | undefined;
+    /**
+     * Determines if the dialog enters a modal state when open.
+     * - `true`: user interaction is limited to just the dialog: focus is trapped, document page scroll is locked, and pointer interactions on outside elements are disabled.
+     * - `false`: user interaction with the rest of the document is allowed.
+     * - `'trap-focus'`: focus is trapped inside the dialog, but document page scroll is not locked and pointer interactions outside of it remain enabled.
+     *
+     * When `modal` is `true` or `'trap-focus'`, render `<Dialog.Close>` inside `<Dialog.Popup>` so
+     * touch screen readers can escape the popup.
+     * @default true
+     */
+    modal?: boolean | 'trap-focus' | undefined;
+    /**
+     * Event handler called when the dialog is opened or closed.
+     */
+    onOpenChange?: ((open: boolean, eventDetails: DialogRoot.ChangeEventDetails) => void) | undefined;
+    /**
+     * Event handler called after any animations complete when the dialog is opened or closed.
+     */
+    onOpenChangeComplete?: ((open: boolean) => void) | undefined;
+    /**
+     * Determines whether the dialog should close on outside clicks.
+     * @default false
+     */
+    disablePointerDismissal?: boolean | undefined;
+    /**
+     * A ref to imperative actions.
+     * - `unmount`: When specified, the dialog will not be unmounted when closed.
+     * Instead, the `unmount` function must be called to unmount the dialog manually.
+     * Useful when the dialog's animation is controlled by an external library.
+     * - `close`: Closes the dialog imperatively when called.
+     */
+    actionsRef?: React_2.RefObject<DialogRoot.Actions | null> | undefined;
+    /**
+     * A handle to associate the dialog with a trigger.
+     * If specified, allows external triggers to control the dialog's open state.
+     * Can be created with the Dialog.createHandle() method.
+     */
+    handle?: DialogHandle<Payload> | undefined;
+    /**
+     * The content of the dialog.
+     * This can be a regular React node or a render function that receives the `payload` of the active trigger.
+     */
+    children?: React_2.ReactNode | PayloadChildRenderFunction<Payload>;
+    /**
+     * ID of the trigger that the dialog is associated with.
+     * This is useful in conjunction with the `open` prop to create a controlled dialog.
+     * There's no need to specify this prop when the dialog is uncontrolled (that is, when the `open` prop is not set).
+     */
+    triggerId?: string | null | undefined;
+    /**
+     * ID of the trigger that the dialog is associated with.
+     * This is useful in conjunction with the `defaultOpen` prop to create an initially open dialog.
+     */
+    defaultTriggerId?: string | null | undefined;
+}
+
+export declare interface DialogRootState {}
+
+declare class DialogStore<Payload> extends ReactStore<Readonly<State<Payload>>, Context, typeof selectors_2> {
+    constructor(initialState?: Partial<State<Payload>>, floatingId?: string | undefined, nested?: boolean);
+    setOpen: (nextOpen: boolean, eventDetails: Omit<DialogRoot.ChangeEventDetails, "preventUnmountOnClose">) => void;
+    static useStore<Payload>(externalStore: DialogStore<Payload> | undefined, initialState?: Partial<State<Payload>>): DialogStore<Payload>;
+}
+
+/**
+ * A heading that labels the dialog.
+ * Renders an `<h2>` element.
+ *
+ * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)
+ */
+export declare const DialogTitle: React_2.ForwardRefExoticComponent<Omit<DialogTitleProps, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;
+
+export declare namespace DialogTitle {
+    export type Props = DialogTitleProps;
+    export type State = DialogTitleState;
+}
+
+export declare interface DialogTitleProps extends BaseUIComponentProps<'h2', DialogTitleState> {}
+
+export declare interface DialogTitleState {}
+
+/**
+ * A button that opens the dialog.
+ * Renders a `<button>` element.
+ *
+ * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)
+ */
+export declare const DialogTrigger: DialogTrigger;
+
+export declare interface DialogTrigger {
+    <Payload>(componentProps: DialogTriggerProps<Payload> & React_2.RefAttributes<HTMLElement>): React_2.JSX.Element;
+}
+
+export declare namespace DialogTrigger {
+    export type Props<Payload = unknown> = DialogTriggerProps<Payload>;
+    export type State = DialogTriggerState;
+}
+
+export declare interface DialogTriggerProps<Payload = unknown> extends NativeButtonProps, BaseUIComponentProps<'button', DialogTriggerState> {
+    /**
+     * A handle to associate the trigger with a dialog.
+     * Can be created with the Dialog.createHandle() method.
+     */
+    handle?: DialogHandle<Payload> | undefined;
+    /**
+     * A payload to pass to the dialog when it is opened.
+     */
+    payload?: Payload | undefined;
+    /**
+     * ID of the trigger. In addition to being forwarded to the rendered element,
+     * it is also used to specify the active trigger for the dialog in controlled mode (with the DialogRoot `triggerId` prop).
+     */
+    id?: string | undefined;
+}
+
+export declare interface DialogTriggerState {
+    /**
+     * Whether the dialog is currently disabled.
+     */
+    disabled: boolean;
+    /**
+     * Whether the dialog is currently open.
+     */
+    open: boolean;
+}
+
+/**
+ * A positioning container for the dialog popup that can be made scrollable.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)
+ */
+export declare const DialogViewport: React_2.ForwardRefExoticComponent<Omit<DialogViewportProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace DialogViewport {
+    export type State = DialogViewportState;
+    export type Props = DialogViewportProps;
+}
+
+export declare interface DialogViewportProps extends BaseUIComponentProps<'div', DialogViewportState> {}
+
+export declare interface DialogViewportState {
+    /**
+     * Whether the dialog is currently open.
+     */
+    open: boolean;
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+    /**
+     * Whether the dialog is nested within another dialog.
+     */
+    nested: boolean;
+    /**
+     * Whether the dialog has nested dialogs open.
+     */
+    nestedDialogOpen: boolean;
+}
+
+declare const disabled: "disabled";
+
+declare const drag: "drag";
+
+declare const escapeKey: "escape-key";
+
+declare interface ExtendedElements {
+    reference: ReferenceType | null;
+    floating: HTMLElement | null;
+    domReference: NarrowedElement<ReferenceType> | null;
+}
+
+declare interface ExtendedRefs {
+    reference: React_2.RefObject<ReferenceType | null>;
+    floating: React_2.RefObject<HTMLElement | null>;
+    domReference: React_2.RefObject<NarrowedElement<ReferenceType> | null>;
+    setReference(node: ReferenceType | null): void;
+    setFloating(node: HTMLElement | null): void;
+    setPositionReference(node: ReferenceType | null): void;
+}
+
+declare type FloatingContext = Omit<UseFloatingReturn<ReferenceType>, 'refs' | 'elements'> & {
+    open: boolean;
+    onOpenChange(open: boolean, eventDetails: BaseUIChangeEventDetails<string>): void;
+    events: FloatingEvents;
+    dataRef: React_2.RefObject<ContextData>;
+    nodeId: string | undefined;
+    floatingId: string | undefined;
+    refs: ExtendedRefs;
+    elements: ExtendedElements;
+    rootStore: FloatingRootContext;
+};
+
+declare interface FloatingEvents {
+    emit<T extends string>(event: T, data?: any): void;
+    on(event: string, handler: (data: any) => void): void;
+    off(event: string, handler: (data: any) => void): void;
+}
+
+/**
+ * Portals the floating element into a given container element — by default,
+ * outside of the app root and into the body.
+ * This is necessary to ensure the floating element can appear outside any
+ * potential parent containers that cause clipping (such as `overflow: hidden`),
+ * while retaining its location in the React tree.
+ * @see https://floating-ui.com/docs/FloatingPortal
+ * @internal
+ */
+declare const FloatingPortal: React_2.ForwardRefExoticComponent<Omit<FloatingPortal.Props<any> & {
+    renderGuards?: boolean | undefined;
+}, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace FloatingPortal {
+    type State = FloatingPortalState;
+    interface Props<TState> extends BaseUIComponentProps<'div', TState> {
+        /**
+         * A parent element to render the portal element into.
+         */
+        container?: UseFloatingPortalNodeProps['container'] | undefined;
+    }
+}
+
+declare interface FloatingPortalState {}
+
+declare type FloatingRootContext = FloatingRootStore;
+
+declare interface FloatingRootState {
+    open: boolean;
+    transitionStatus: TransitionStatus | undefined;
+    domReferenceElement: Element | null;
+    referenceElement: ReferenceType | null;
+    floatingElement: HTMLElement | null;
+    positionReference: ReferenceType | null;
+    /**
+     * The ID of the floating element.
+     */
+    floatingId: string | undefined;
+}
+
+declare class FloatingRootStore extends ReactStore<Readonly<FloatingRootState>, FloatingRootStoreContext, typeof selectors> {
+    private readonly syncOnly;
+    constructor(options: FloatingRootStoreOptions);
+    /**
+     * Syncs the event used by hover logic to distinguish hover-open from click-like interaction.
+     */
+    syncOpenEvent: (newOpen: boolean, event: Event | undefined) => void;
+    /**
+     * Runs the root-owned side effects for an open state change.
+     */
+    dispatchOpenChange: (newOpen: boolean, eventDetails: BaseUIChangeEventDetails<string>) => void;
+    /**
+     * Emits the `openchange` event through the internal event emitter and calls the `onOpenChange` handler with the provided arguments.
+     *
+     * @param newOpen The new open state.
+     * @param eventDetails Details about the event that triggered the open state change.
+     */
+    setOpen: (newOpen: boolean, eventDetails: BaseUIChangeEventDetails<string>) => void;
+}
+
+declare interface FloatingRootStoreContext {
+    onOpenChange: ((open: boolean, eventDetails: BaseUIChangeEventDetails<string>) => void) | undefined;
+    readonly dataRef: React_2.RefObject<ContextData>;
+    readonly events: FloatingEvents;
+    nested: boolean;
+    readonly triggerElements: PopupTriggerMap;
+}
+
+declare interface FloatingRootStoreOptions {
+    open: boolean;
+    transitionStatus: TransitionStatus | undefined;
+    referenceElement: ReferenceType | null;
+    floatingElement: HTMLElement | null;
+    triggerElements: PopupTriggerMap;
+    floatingId: string | undefined;
+    /**
+     * When true, `setOpen` only forwards to `onOpenChange`.
+     * The popup store owns `dispatchOpenChange(...)` in this mode.
+     */
+    syncOnly: boolean;
+    nested: boolean;
+    onOpenChange: ((open: boolean, eventDetails: BaseUIChangeEventDetails<string>) => void) | undefined;
+}
+
+declare const focusOut: "focus-out";
+
+declare type HTMLProps<T = any> = React_2.HTMLAttributes<T> & {
+    ref?: React_2.Ref<T> | undefined;
+};
+
+declare const imperativeAction: "imperative-action";
+
+declare const incrementPress: "increment-press";
+
+declare const initial: "initial";
+
+declare const inputBlur: "input-blur";
+
+declare const inputChange: "input-change";
+
+declare const inputClear: "input-clear";
+
+declare const inputPaste: "input-paste";
+
+declare const inputPress: "input-press";
+
+declare const itemPress: "item-press";
+
+declare const keyboard: "keyboard";
+
+declare const linkPress: "link-press";
+
+declare const listNavigation: "list-navigation";
+
+declare const missing: "missing";
+
+declare type NarrowedElement<T> = T extends Element ? T : Element;
+
+declare interface NativeButtonProps {
+    /**
+     * Whether the component renders a native `<button>` element when replacing it
+     * via the `render` prop.
+     * Set to `false` if the rendered element is not a button (for example, `<div>`).
+     * @default true
+     */
+    nativeButton?: boolean | undefined;
+}
+
+declare const none: "none";
+
+declare const outsidePress: "outside-press";
+
+declare type PayloadChildRenderFunction<Payload> = (arg: {
+    payload: Payload | undefined;
+}) => React_2.ReactNode;
+
+declare const pointer: "pointer";
+
+declare type PopupStoreContext<ChangeEventDetails> = {
+    /**
+     * Map of registered trigger elements.
+     */
+    readonly triggerElements: PopupTriggerMap;
+    /**
+     * Reference to the popup element.
+     */
+    readonly popupRef: React.RefObject<HTMLElement | null>;
+    /**
+     * Callback fired when the open state changes.
+     */
+    onOpenChange?: ((open: boolean, eventDetails: ChangeEventDetails) => void) | undefined;
+    /**
+     * Callback fired when the open state change animation completes.
+     */
+    onOpenChangeComplete: ((open: boolean) => void) | undefined;
+};
+
+/**
+ * State common to all popup stores.
+ */
+declare type PopupStoreState<Payload> = {
+    /**
+     * Whether the popup is open (internal state).
+     */
+    open: boolean;
+    /**
+     * Whether the popup is open (external prop).
+     */
+    readonly openProp: boolean | undefined;
+    /**
+     * Whether the popup should be mounted in the DOM.
+     * This usually follows `open` but can be different during exit transitions.
+     */
+    mounted: boolean;
+    /**
+     * The current enter/exit transition status of the popup.
+     */
+    transitionStatus: TransitionStatus;
+    floatingRootContext: FloatingRootContext;
+    floatingId: string | undefined;
+    /**
+     * Number of trigger elements currently registered for this popup.
+     */
+    triggerCount: number;
+    /**
+     * Whether to prevent unmounting the popup when closed.
+     * Useful for interacting with JS animation libraries that control unmounting themselves.
+     */
+    preventUnmountingOnClose: boolean;
+    /**
+     * Optional payload set by the trigger.
+     */
+    payload: Payload | undefined;
+    /**
+     * ID of the currently active trigger.
+     */
+    activeTriggerId: string | null;
+    /**
+     * The currently active trigger DOM element.
+     */
+    activeTriggerElement: Element | null;
+    /**
+     * ID of the trigger (external prop).
+     */
+    readonly triggerIdProp: string | null | undefined;
+    /**
+     * The popup DOM element.
+     */
+    popupElement: HTMLElement | null;
+    /**
+     * The positioner DOM element.
+     */
+    positionerElement: HTMLElement | null;
+    /**
+     * Props to spread onto the active trigger element.
+     */
+    activeTriggerProps: HTMLProps;
+    /**
+     * Props to spread onto inactive trigger elements.
+     */
+    inactiveTriggerProps: HTMLProps;
+    /**
+     * Props to spread onto the popup element.
+     */
+    popupProps: HTMLProps;
+};
+
+/**
+ * Data structure to keep track of popup trigger elements by their IDs.
+ * Uses both a set of Elements and a map of IDs to Elements for efficient lookups.
+ */
+declare class PopupTriggerMap {
+    private elementsSet;
+    private idMap;
+    constructor();
+    /**
+     * Adds a trigger element with the given ID.
+     *
+     * Note: The provided element is assumed to not be registered under multiple IDs.
+     */
+    add(id: string, element: Element): void;
+    /**
+     * Removes the trigger element with the given ID.
+     */
+    delete(id: string): void;
+    /**
+     * Whether the given element is registered as a trigger.
+     */
+    hasElement(element: Element): boolean;
+    /**
+     * Whether there is a registered trigger element matching the given predicate.
+     */
+    hasMatchingElement(predicate: (el: Element) => boolean): boolean;
+    /**
+     * Returns the trigger element associated with the given ID, or undefined if no such element exists.
+     */
+    getById(id: string): Element | undefined;
+    /**
+     * Returns an iterable of all registered trigger entries, where each entry is a tuple of [id, element].
+     */
+    entries(): IterableIterator<[string, Element]>;
+    /**
+     * Returns an iterable of all registered trigger elements.
+     */
+    elements(): IterableIterator<Element>;
+    /**
+     * Returns the number of registered trigger elements.
+     */
+    get size(): number;
+}
+
+declare namespace REASONS {
+    export {
+        none,
+        triggerPress,
+        triggerHover,
+        triggerFocus,
+        outsidePress,
+        itemPress,
+        closePress,
+        linkPress,
+        clearPress,
+        chipRemovePress,
+        trackPress,
+        incrementPress,
+        decrementPress,
+        inputChange,
+        inputClear,
+        inputBlur,
+        inputPaste,
+        inputPress,
+        focusOut,
+        escapeKey,
+        closeWatcher,
+        listNavigation,
+        keyboard,
+        pointer,
+        drag,
+        wheel,
+        scrub,
+        cancelOpen,
+        siblingOpen,
+        disabled,
+        missing,
+        initial,
+        imperativeAction,
+        swipe,
+        windowResize
+    }
+}
+
+/**
+ * Maps a change `reason` string to the corresponding native event type.
+ */
+declare type ReasonToEvent<Reason extends string> = Reason extends keyof ReasonToEventMap ? ReasonToEventMap[Reason] : Event;
+
+declare interface ReasonToEventMap {
+    [REASONS.none]: Event;
+    [REASONS.triggerPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
+    [REASONS.triggerHover]: MouseEvent;
+    [REASONS.triggerFocus]: FocusEvent;
+    [REASONS.outsidePress]: MouseEvent | PointerEvent | TouchEvent;
+    [REASONS.itemPress]: MouseEvent | KeyboardEvent | PointerEvent;
+    [REASONS.closePress]: MouseEvent | KeyboardEvent | PointerEvent;
+    [REASONS.linkPress]: MouseEvent | PointerEvent;
+    [REASONS.clearPress]: PointerEvent | MouseEvent | KeyboardEvent;
+    [REASONS.chipRemovePress]: PointerEvent | MouseEvent | KeyboardEvent;
+    [REASONS.trackPress]: PointerEvent | MouseEvent | TouchEvent;
+    [REASONS.incrementPress]: PointerEvent | MouseEvent | TouchEvent;
+    [REASONS.decrementPress]: PointerEvent | MouseEvent | TouchEvent;
+    [REASONS.inputChange]: InputEvent | Event;
+    [REASONS.inputClear]: InputEvent | FocusEvent | Event;
+    [REASONS.inputBlur]: FocusEvent;
+    [REASONS.inputPaste]: ClipboardEvent;
+    [REASONS.inputPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
+    [REASONS.focusOut]: FocusEvent | KeyboardEvent;
+    [REASONS.escapeKey]: KeyboardEvent;
+    [REASONS.closeWatcher]: Event;
+    [REASONS.listNavigation]: KeyboardEvent;
+    [REASONS.keyboard]: KeyboardEvent;
+    [REASONS.pointer]: PointerEvent;
+    [REASONS.drag]: PointerEvent | TouchEvent;
+    [REASONS.swipe]: PointerEvent | TouchEvent;
+    [REASONS.wheel]: WheelEvent;
+    [REASONS.scrub]: PointerEvent;
+    [REASONS.cancelOpen]: MouseEvent;
+    [REASONS.siblingOpen]: Event;
+    [REASONS.disabled]: Event;
+    [REASONS.missing]: Event;
+    [REASONS.initial]: Event;
+    [REASONS.imperativeAction]: Event;
+    [REASONS.windowResize]: UIEvent;
+}
+
+declare type ReferenceType = Element | VirtualElement;
+
+declare const scrub: "scrub";
+
+declare const selectors: {
+    open: (state: FloatingRootState) => boolean;
+    transitionStatus: (state: FloatingRootState) => TransitionStatus;
+    domReferenceElement: (state: FloatingRootState) => Element | null;
+    referenceElement: (state: FloatingRootState) => ReferenceType | null;
+    floatingElement: (state: FloatingRootState) => HTMLElement | null;
+    floatingId: (state: FloatingRootState) => string | undefined;
+};
+
+declare const selectors_2: {
+    modal: (state: State<unknown>) => boolean | "trap-focus";
+    nested: (state: State<unknown>) => boolean;
+    nestedOpenDialogCount: (state: State<unknown>) => number;
+    nestedOpenDrawerCount: (state: State<unknown>) => number;
+    disablePointerDismissal: (state: State<unknown>) => boolean;
+    openMethod: (state: State<unknown>) => InteractionType | null;
+    descriptionElementId: (state: State<unknown>) => string | undefined;
+    titleElementId: (state: State<unknown>) => string | undefined;
+    viewportElement: (state: State<unknown>) => HTMLElement | null;
+    role: (state: State<unknown>) => "dialog" | "alertdialog";
+    open: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }) => boolean;
+    mounted: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }) => boolean;
+    transitionStatus: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }) => TransitionStatus_2;
+    floatingRootContext: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }) => FloatingRootStore_2;
+    triggerCount: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }) => number;
+    preventUnmountingOnClose: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }) => boolean;
+    payload: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }) => unknown;
+    activeTriggerId: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }) => string | null;
+    activeTriggerElement: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }) => Element | null;
+    popupId: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }) => string | undefined;
+    isTriggerActive: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }, triggerId: string | undefined) => boolean;
+    isOpenedByTrigger: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }, triggerId: string | undefined) => boolean;
+    isMountedByTrigger: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }, triggerId: string | undefined) => boolean;
+    triggerProps: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }, isActive: boolean) => HTMLProps_2;
+    triggerPopupId: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }, triggerId: string | undefined) => string | undefined;
+    popupProps: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }) => HTMLProps_2;
+    popupElement: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }) => HTMLElement | null;
+    positionerElement: (state: {
+        open: boolean;
+        readonly openProp: boolean | undefined;
+        mounted: boolean;
+        transitionStatus: TransitionStatus_2;
+        floatingRootContext: FloatingRootContext_2;
+        floatingId: string | undefined;
+        triggerCount: number;
+        preventUnmountingOnClose: boolean;
+        payload: unknown;
+        activeTriggerId: string | null;
+        activeTriggerElement: Element | null;
+        readonly triggerIdProp: string | null | undefined;
+        popupElement: HTMLElement | null;
+        positionerElement: HTMLElement | null;
+        activeTriggerProps: HTMLProps_2;
+        inactiveTriggerProps: HTMLProps_2;
+        popupProps: HTMLProps_2;
+    }) => HTMLElement | null;
+};
+
+declare const siblingOpen: "sibling-open";
+
+declare type State<Payload> = PopupStoreState<Payload> & {
+    modal: boolean | 'trap-focus';
+    disablePointerDismissal: boolean;
+    openMethod: InteractionType | null;
+    nested: boolean;
+    nestedOpenDialogCount: number;
+    nestedOpenDrawerCount: number;
+    titleElementId: string | undefined;
+    descriptionElementId: string | undefined;
+    viewportElement: HTMLElement | null;
+    role: 'dialog' | 'alertdialog';
+};
+
+declare const swipe: "swipe";
+
+declare const trackPress: "track-press";
+
+declare type TransitionStatus = 'starting' | 'ending' | 'idle' | undefined;
+
 declare function Trigger<Payload = unknown>({ className, ...props }: WithStringClassName<Dialog_2.Trigger.Props<Payload>> & React_2.RefAttributes<HTMLElement>): JSX_2.Element;
 
+declare const triggerFocus: "trigger-focus";
+
+declare const triggerHover: "trigger-hover";
+
+declare const triggerPress: "trigger-press";
+
+declare interface UseFloatingPortalNodeProps {
+    ref?: React_2.Ref<HTMLDivElement> | undefined;
+    container?: HTMLElement | ShadowRoot | null | React_2.RefObject<HTMLElement | ShadowRoot | null> | undefined;
+    componentProps?: UseRenderElementComponentProps<any> | undefined;
+    elementProps?: React_2.HTMLAttributes<HTMLDivElement> | undefined;
+}
+
+declare interface UseRenderElementComponentProps<State> {
+    /**
+     * The class name to apply to the rendered element.
+     * Can be a string or a function that accepts the state and returns a string.
+     */
+    className?: string | ((state: State) => string | undefined) | undefined;
+    /**
+     * The render prop or React element to override the default element.
+     */
+    render?: undefined | React_2.ReactElement | ComponentRenderFn<React_2.HTMLAttributes<any>, State>;
+    /**
+     * The style to apply to the rendered element.
+     * Can be a style object or a function that accepts the state and returns a style object.
+     */
+    style?: React_2.CSSProperties | ((state: State) => React_2.CSSProperties | undefined) | undefined;
+}
+
+declare const wheel: "wheel";
+
+declare const windowResize: "window-resize";
+
+/**
+ * Adds a `preventBaseUIHandler` method to all event handlers.
+ */
+declare type WithBaseUIEvent<T> = { [K in keyof T]: WithPreventBaseUIHandler<T[K]> };
+
+declare type WithPreventBaseUIHandler<T> = T extends ((event: infer E) => any) ? E extends React_2.SyntheticEvent<Element, Event> ? (event: BaseUIEvent<E>) => ReturnType<T> : T : T extends undefined ? undefined : T;
+
 declare type WithStringClassName<P> = Omit<P, 'className'> & {
     className?: string;
 };
 
-
-export * from "@base-ui/react/dialog";
-
 export { }