@wix/site-ui 1.30.0 → 1.32.0

package/dist/Drawer/index.d.ts

@@ -1,38 +1,293 @@
-import { Drawer as Drawer_2 } from '@base-ui/react/drawer';
-import { DrawerBackdropProps } from '@base-ui/react/drawer';
-import { DrawerContentProps } from '@base-ui/react/drawer';
-import { DrawerIndentBackgroundProps } from '@base-ui/react/drawer';
-import { DrawerIndentProps } from '@base-ui/react/drawer';
-import { DrawerPopupProps } from '@base-ui/react/drawer';
-import { DrawerSwipeAreaProps } from '@base-ui/react/drawer';
-import { DrawerViewportProps } from '@base-ui/react/drawer';
+import { DrawerBackdropProps as DrawerBackdropProps_2 } from '@base-ui/react/drawer';
+import { DrawerContentProps as DrawerContentProps_2 } from '@base-ui/react/drawer';
+import { DrawerIndentBackgroundProps as DrawerIndentBackgroundProps_2 } from '@base-ui/react/drawer';
+import { DrawerIndentProps as DrawerIndentProps_2 } from '@base-ui/react/drawer';
+import { DrawerPopupProps as DrawerPopupProps_2 } from '@base-ui/react/drawer';
+import { DrawerSwipeAreaProps as DrawerSwipeAreaProps_2 } from '@base-ui/react/drawer';
+import { DrawerViewportProps as DrawerViewportProps_2 } from '@base-ui/react/drawer';
+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 function Close({ className, ...props }: WithStringClassName<Drawer_2.Close.Props>): JSX_2.Element;
 
+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";
+
 declare function Description({ className, ...props }: WithStringClassName<Drawer_2.Description.Props>): JSX_2.Element;
 
+/**
+ * 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;
+}
+
+/**
+ * Groups all parts of the dialog.
+ * Doesn't render its own HTML element.
+ *
+ * Documentation: [Base UI Dialog](https://base-ui.com/react/components/dialog)
+ */
+declare function DialogRoot<Payload>(props: DialogRoot.Props<Payload>): JSX_2.Element;
+
+declare namespace DialogRoot {
+    type State = DialogRootState;
+    type Props<Payload = unknown> = DialogRootProps<Payload>;
+    type Actions = DialogRootActions;
+    type ChangeEventReason = DialogRootChangeEventReason;
+    type ChangeEventDetails = DialogRootChangeEventDetails;
+}
+
+declare interface DialogRootActions {
+    unmount: () => void;
+    close: () => void;
+}
+
+declare type DialogRootChangeEventDetails = BaseUIChangeEventDetails<DialogRoot.ChangeEventReason> & {
+    preventUnmountOnClose(): void;
+};
+
+declare type DialogRootChangeEventReason = typeof REASONS.triggerPress | typeof REASONS.outsidePress | typeof REASONS.escapeKey | typeof REASONS.closePress | typeof REASONS.focusOut | typeof REASONS.imperativeAction | typeof REASONS.none;
+
+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;
+}
+
+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>;
+}
+
+declare const disabled: "disabled";
+
+declare const drag: "drag";
+
 export declare const Drawer: {
-    Backdrop: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DrawerBackdropProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Backdrop: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DrawerBackdropProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Content: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DrawerContentProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Content: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DrawerContentProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Indent: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DrawerIndentProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Indent: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DrawerIndentProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    IndentBackground: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DrawerIndentBackgroundProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    IndentBackground: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DrawerIndentBackgroundProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Popup: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DrawerPopupProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Popup: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DrawerPopupProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    SwipeArea: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DrawerSwipeAreaProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    SwipeArea: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DrawerSwipeAreaProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Viewport: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DrawerViewportProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Viewport: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<DrawerViewportProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
     Root: typeof Drawer_2.Root;
@@ -46,15 +301,1395 @@ export declare const Drawer: {
     createHandle: typeof Drawer_2.createHandle;
 };
 
+export declare namespace Drawer_2 {
+    export {
+        DrawerBackdrop as Backdrop,
+        DrawerClose as Close,
+        DrawerContent as Content,
+        DrawerDescription as Description,
+        DrawerIndent as Indent,
+        DrawerIndentBackground as IndentBackground,
+        DrawerPopup as Popup,
+        DrawerPortal as Portal,
+        DrawerProvider as Provider,
+        DrawerRoot as Root,
+        DrawerSwipeArea as SwipeArea,
+        DrawerTitle as Title,
+        DrawerTrigger as Trigger,
+        DrawerViewport as Viewport,
+        createDialogHandle as createHandle,
+        DialogHandle as Handle
+    }
+}
+
+/**
+ * An overlay displayed beneath the popup.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+export declare const DrawerBackdrop: React_2.ForwardRefExoticComponent<Omit<DrawerBackdropProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace DrawerBackdrop {
+    export type Props = DrawerBackdropProps;
+    export type State = DrawerBackdropState;
+}
+
+export declare interface DrawerBackdropProps extends BaseUIComponentProps<'div', DrawerBackdropState> {
+    /**
+     * Whether the backdrop is forced to render even when nested.
+     * @default false
+     */
+    forceRender?: boolean | undefined;
+}
+
+export declare interface DrawerBackdropState {
+    /**
+     * Whether the drawer is currently open.
+     */
+    open: boolean;
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+}
+
+/**
+ * A button that closes the drawer.
+ * Renders a `<button>` element.
+ *
+ * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+export declare const DrawerClose: DrawerClose;
+
+export declare interface DrawerClose {
+    (componentProps: DrawerCloseProps): React_2.JSX.Element;
+}
+
+export declare namespace DrawerClose {
+    export type Props = DrawerCloseProps;
+    export type State = DrawerCloseState;
+}
+
+export declare interface DrawerCloseProps extends NativeButtonProps, BaseUIComponentProps<'button', DrawerCloseState> {}
+
+export declare interface DrawerCloseState {
+    /**
+     * Whether the button is currently disabled.
+     */
+    disabled: boolean;
+}
+
+/**
+ * A container for the drawer contents.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+export declare const DrawerContent: React_2.ForwardRefExoticComponent<Omit<DrawerContentProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace DrawerContent {
+    export type Props = DrawerContentProps;
+    export type State = DrawerContentState;
+}
+
+export declare interface DrawerContentProps extends BaseUIComponentProps<'div', DrawerContentState> {}
+
+export declare interface DrawerContentState {}
+
+/**
+ * A paragraph with additional information about the drawer.
+ * Renders a `<p>` element.
+ *
+ * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+export declare const DrawerDescription: DrawerDescription;
+
+export declare interface DrawerDescription {
+    (componentProps: DrawerDescriptionProps): React_2.JSX.Element;
+}
+
+export declare namespace DrawerDescription {
+    export type Props = DrawerDescriptionProps;
+    export type State = DrawerDescriptionState;
+}
+
+export declare interface DrawerDescriptionProps extends BaseUIComponentProps<'p', DrawerDescriptionState> {}
+
+export declare interface DrawerDescriptionState {}
+
+/**
+ * A wrapper element intended to contain your app's main UI.
+ * Applies `data-active` when any drawer within the nearest `<Drawer.Provider>` is open.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+export declare const DrawerIndent: React_2.ForwardRefExoticComponent<Omit<DrawerIndentProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace DrawerIndent {
+    export type State = DrawerIndentState;
+    export type Props = DrawerIndentProps;
+}
+
+/**
+ * An element placed before `<Drawer.Indent>` to render a background layer that can be styled based on whether any drawer is open.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+export declare const DrawerIndentBackground: React_2.ForwardRefExoticComponent<Omit<DrawerIndentBackgroundProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace DrawerIndentBackground {
+    export type State = DrawerIndentBackgroundState;
+    export type Props = DrawerIndentBackgroundProps;
+}
+
+export declare interface DrawerIndentBackgroundProps extends BaseUIComponentProps<'div', DrawerIndentBackgroundState> {}
+
+export declare interface DrawerIndentBackgroundState {
+    /**
+     * Whether any drawer within the nearest <Drawer.Provider> is open.
+     */
+    active: boolean;
+}
+
+export declare interface DrawerIndentProps extends BaseUIComponentProps<'div', DrawerIndentState> {}
+
+export declare interface DrawerIndentState {
+    /**
+     * Whether any drawer within the nearest <Drawer.Provider> is open.
+     */
+    active: boolean;
+}
+
+/**
+ * A container for the drawer contents.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+export declare const DrawerPopup: React_2.ForwardRefExoticComponent<Omit<DrawerPopupProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace DrawerPopup {
+    export type Props = DrawerPopupProps;
+    export type State = DrawerPopupState;
+}
+
+export declare interface DrawerPopupProps extends BaseUIComponentProps<'div', DrawerPopupState> {
+    /**
+     * Determines the element to focus when the drawer 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 drawer 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 DrawerPopupState {
+    /**
+     * Whether the drawer is currently open.
+     */
+    open: boolean;
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+    /**
+     * Whether the active snap point is the full-height expanded state.
+     */
+    expanded: boolean;
+    /**
+     * Whether the drawer is nested within a parent drawer.
+     */
+    nested: boolean;
+    /**
+     * Whether the drawer has nested drawers open.
+     */
+    nestedDrawerOpen: boolean;
+    /**
+     * Whether a nested drawer is currently being swiped.
+     */
+    nestedDrawerSwiping: boolean;
+    /**
+     * The swipe direction used to dismiss the drawer.
+     */
+    swipeDirection: DrawerSwipeDirection;
+    /**
+     * Whether the drawer is being swiped.
+     */
+    swiping: 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 Drawer](https://base-ui.com/react/components/drawer)
+ */
+export declare const DrawerPortal: DrawerPortal;
+
+export declare interface DrawerPortal {
+    (componentProps: DrawerPortalProps & React_2.RefAttributes<HTMLDivElement>): React_2.JSX.Element | null;
+}
+
+export declare namespace DrawerPortal {
+    export type Props = DrawerPortalProps;
+    export type State = DrawerPortalState;
+}
+
+export declare interface DrawerPortalProps extends FloatingPortal.Props<DrawerPortalState> {
+    /**
+     * 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<DrawerPortalState>['container'] | undefined;
+}
+
+export declare interface DrawerPortalState {}
+
+/**
+ * Provides a shared context for coordinating global Drawer UI, such as indent/background effects based on whether any Drawer is open.
+ * Doesn't render its own HTML element.
+ *
+ * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+export declare function DrawerProvider(props: DrawerProvider.Props): JSX_2.Element;
+
+export declare namespace DrawerProvider {
+    export type State = DrawerProviderState;
+    export type Props = DrawerProviderProps;
+}
+
+export declare interface DrawerProviderProps {
+    children?: React_2.ReactNode;
+}
+
+export declare interface DrawerProviderState {}
+
+/**
+ * Groups all parts of the drawer.
+ * Doesn't render its own HTML element.
+ *
+ * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+export declare function DrawerRoot<Payload = unknown>(props: DrawerRoot.Props<Payload>): JSX_2.Element;
+
+export declare namespace DrawerRoot {
+    export type State = DrawerRootState;
+    export type Props<Payload = unknown> = DrawerRootProps<Payload>;
+    export type Actions = DrawerRootActions;
+    export type ChangeEventReason = DrawerRootChangeEventReason;
+    export type ChangeEventDetails = DrawerRootChangeEventDetails;
+    export type SnapPointChangeEventReason = DrawerRootSnapPointChangeEventReason;
+    export type SnapPointChangeEventDetails = DrawerRootSnapPointChangeEventDetails;
+    export type SnapPoint = DrawerSnapPoint;
+}
+
+export declare interface DrawerRootActions {
+    unmount: () => void;
+    close: () => void;
+}
+
+export declare type DrawerRootChangeEventDetails = BaseUIChangeEventDetails<DrawerRoot.ChangeEventReason> & {
+    preventUnmountOnClose(): void;
+};
+
+export declare type DrawerRootChangeEventReason = typeof REASONS.triggerPress | typeof REASONS.outsidePress | typeof REASONS.escapeKey | typeof REASONS.closeWatcher | typeof REASONS.closePress | typeof REASONS.focusOut | typeof REASONS.imperativeAction | typeof REASONS.swipe | typeof REASONS.none;
+
+export declare interface DrawerRootProps<Payload = unknown> {
+    /**
+     * Whether the drawer is currently open.
+     */
+    open?: boolean | undefined;
+    /**
+     * Whether the drawer is initially open.
+     *
+     * To render a controlled drawer, use the `open` prop instead.
+     * @default false
+     */
+    defaultOpen?: boolean | undefined;
+    /**
+     * Determines if the drawer enters a modal state when open.
+     * - `true`: user interaction is limited to just the drawer: 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 drawer, but document page scroll is not locked and pointer interactions outside of it remain enabled.
+     * @default true
+     */
+    modal?: boolean | 'trap-focus' | undefined;
+    /**
+     * Event handler called when the drawer is opened or closed.
+     */
+    onOpenChange?: ((open: boolean, eventDetails: DrawerRoot.ChangeEventDetails) => void) | undefined;
+    /**
+     * Event handler called after any animations complete when the drawer is opened or closed.
+     */
+    onOpenChangeComplete?: ((open: boolean) => void) | undefined;
+    /**
+     * Determines whether the drawer should close on outside clicks.
+     * @default false
+     */
+    disablePointerDismissal?: boolean | undefined;
+    /**
+     * A ref to imperative actions.
+     * - `unmount`: When specified, the drawer will not be unmounted when closed.
+     * Instead, the `unmount` function must be called to unmount the drawer manually.
+     * Useful when the drawer's animation is controlled by an external library.
+     * - `close`: Closes the drawer imperatively when called.
+     */
+    actionsRef?: React_2.RefObject<DrawerRoot.Actions | null> | undefined;
+    /**
+     * A handle to associate the drawer with a trigger.
+     * If specified, allows detached triggers to control the drawer's open state.
+     * Can be created with the Drawer.createHandle() method.
+     */
+    handle?: DialogHandle<Payload> | undefined;
+    /**
+     * ID of the trigger that the drawer is associated with.
+     * This is useful in conjunction with the `open` prop to create a controlled drawer.
+     * There's no need to specify this prop when the drawer is uncontrolled (that is, when the `open` prop is not set).
+     */
+    triggerId?: string | null | undefined;
+    /**
+     * ID of the trigger that the drawer is associated with.
+     * This is useful in conjunction with the `defaultOpen` prop to create an initially open drawer.
+     */
+    defaultTriggerId?: string | null | undefined;
+    /**
+     * The content of the drawer.
+     */
+    children?: React_2.ReactNode | PayloadChildRenderFunction<Payload>;
+    /**
+     * The swipe direction used to dismiss the drawer.
+     * @default 'down'
+     */
+    swipeDirection?: DrawerSwipeDirection | undefined;
+    /**
+     * Snap points used to position the drawer.
+     * Use numbers between 0 and 1 to represent fractions of the viewport height,
+     * numbers greater than 1 as pixel values, or strings in `px`/`rem` units
+     * (for example, `'148px'` or `'30rem'`).
+     */
+    snapPoints?: DrawerSnapPoint[] | undefined;
+    /**
+     * Disables velocity-based snap skipping so drag distance determines the next snap point.
+     * @default false
+     */
+    snapToSequentialPoints?: boolean | undefined;
+    /**
+     * The currently active snap point. Use with `onSnapPointChange` to control the snap point.
+     */
+    snapPoint?: DrawerSnapPoint | null | undefined;
+    /**
+     * The initial snap point value when uncontrolled.
+     */
+    defaultSnapPoint?: DrawerSnapPoint | null | undefined;
+    /**
+     * Callback fired when the snap point changes.
+     */
+    onSnapPointChange?: ((snapPoint: DrawerSnapPoint | null, eventDetails: DrawerRoot.SnapPointChangeEventDetails) => void) | undefined;
+}
+
+export declare type DrawerRootSnapPointChangeEventDetails = BaseUIChangeEventDetails<DrawerRootSnapPointChangeEventReason>;
+
+export declare type DrawerRootSnapPointChangeEventReason = DrawerRootChangeEventReason;
+
+export declare interface DrawerRootState {}
+
+declare type DrawerSnapPoint = number | string;
+
+/**
+ * An invisible area that listens for swipe gestures to open the drawer.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+export declare const DrawerSwipeArea: React_2.ForwardRefExoticComponent<Omit<DrawerSwipeAreaProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace DrawerSwipeArea {
+    export type Props = DrawerSwipeAreaProps;
+    export type State = DrawerSwipeAreaState;
+}
+
+export declare interface DrawerSwipeAreaProps extends BaseUIComponentProps<'div', DrawerSwipeAreaState> {
+    /**
+     * Whether the swipe area is disabled.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * The swipe direction that opens the drawer.
+     * Defaults to the opposite of `Drawer.Root` `swipeDirection`.
+     */
+    swipeDirection?: DrawerSwipeDirection | undefined;
+}
+
+export declare interface DrawerSwipeAreaState {
+    /**
+     * Whether the drawer is currently open.
+     */
+    open: boolean;
+    /**
+     * Whether the swipe area is currently being swiped.
+     */
+    swiping: boolean;
+    /**
+     * The swipe direction that opens the drawer.
+     */
+    swipeDirection: SwipeDirection;
+    /**
+     * Whether the swipe area is disabled.
+     */
+    disabled: boolean;
+}
+
+declare type DrawerSwipeDirection = SwipeDirection;
+
+/**
+ * A heading that labels the drawer.
+ * Renders an `<h2>` element.
+ *
+ * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+export declare const DrawerTitle: DrawerTitle;
+
+export declare interface DrawerTitle {
+    (componentProps: DrawerTitleProps): React_2.JSX.Element;
+}
+
+export declare namespace DrawerTitle {
+    export type Props = DrawerTitleProps;
+    export type State = DrawerTitleState;
+}
+
+export declare interface DrawerTitleProps extends BaseUIComponentProps<'h2', DrawerTitleState> {}
+
+export declare interface DrawerTitleState {}
+
+/**
+ * A button that opens the drawer.
+ * Renders a `<button>` element.
+ *
+ * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+export declare const DrawerTrigger: DrawerTrigger;
+
+export declare interface DrawerTrigger {
+    <Payload>(componentProps: DrawerTriggerProps<Payload> & React_2.RefAttributes<HTMLElement>): React_2.JSX.Element;
+}
+
+export declare namespace DrawerTrigger {
+    export type Props<Payload = unknown> = DrawerTriggerProps<Payload>;
+    export type State = DrawerTriggerState;
+}
+
+export declare interface DrawerTriggerProps<Payload = unknown> extends NativeButtonProps, BaseUIComponentProps<'button', DrawerTriggerState> {
+    /**
+     * A handle to associate the trigger with a drawer.
+     * Can be created with the Drawer.createHandle() method.
+     */
+    handle?: DialogHandle<Payload> | undefined;
+    /**
+     * A payload to pass to the drawer 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 drawers in controlled mode (with the Drawer.Root `triggerId` prop).
+     */
+    id?: string | undefined;
+}
+
+export declare interface DrawerTriggerState {
+    /**
+     * Whether the drawer is currently disabled.
+     */
+    disabled: boolean;
+    /**
+     * Whether the drawer is currently open.
+     */
+    open: boolean;
+}
+
+/**
+ * A positioning container for the drawer popup that can be made scrollable.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+export declare const DrawerViewport: React_2.ForwardRefExoticComponent<Omit<DrawerViewportProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace DrawerViewport {
+    export type Props = DrawerViewportProps;
+    export type State = DrawerViewportState;
+}
+
+export declare interface DrawerViewportProps extends BaseUIComponentProps<'div', DrawerViewportState> {}
+
+export declare interface DrawerViewportState {
+    /**
+     * Whether the drawer is currently open.
+     */
+    open: boolean;
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+    /**
+     * Whether the drawer is nested within another drawer.
+     */
+    nested: boolean;
+    /**
+     * Whether the drawer has nested drawers open.
+     */
+    nestedDialogOpen: boolean;
+}
+
+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 type SwipeDirection = 'up' | 'down' | 'left' | 'right';
+
 declare function Title({ className, ...props }: WithStringClassName<Drawer_2.Title.Props>): JSX_2.Element;
 
+declare const trackPress: "track-press";
+
+declare type TransitionStatus = 'starting' | 'ending' | 'idle' | undefined;
+
 declare function Trigger<Payload = unknown>({ className, ...props }: WithStringClassName<Drawer_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/drawer";
-
 export { }