@wix/site-ui 1.30.0 → 1.32.0

package/dist/Popover/index.d.ts

@@ -1,35 +1,347 @@
+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 { Popover as Popover_2 } from '@base-ui/react/popover';
-import { PopoverArrowProps } from '@base-ui/react/popover';
-import { PopoverBackdropProps } from '@base-ui/react/popover';
-import { PopoverCloseProps } from '@base-ui/react/popover';
-import { PopoverDescriptionProps } from '@base-ui/react/popover';
-import { PopoverPopupProps } from '@base-ui/react/popover';
-import { PopoverPortalProps } from '@base-ui/react/popover';
-import { PopoverPositionerProps } from '@base-ui/react/popover';
-import { PopoverTitleProps } from '@base-ui/react/popover';
+import { Padding } from '@floating-ui/react-dom';
+import { PopoverArrowProps as PopoverArrowProps_2 } from '@base-ui/react/popover';
+import { PopoverBackdropProps as PopoverBackdropProps_2 } from '@base-ui/react/popover';
+import { PopoverCloseProps as PopoverCloseProps_2 } from '@base-ui/react/popover';
+import { PopoverDescriptionProps as PopoverDescriptionProps_2 } from '@base-ui/react/popover';
+import { PopoverPopupProps as PopoverPopupProps_2 } from '@base-ui/react/popover';
+import { PopoverPortalProps as PopoverPortalProps_2 } from '@base-ui/react/popover';
+import { PopoverPositionerProps as PopoverPositionerProps_2 } from '@base-ui/react/popover';
+import { PopoverRootChangeEventReason as PopoverRootChangeEventReason_2 } from '../index.js';
+import { PopoverTitleProps as PopoverTitleProps_2 } from '@base-ui/react/popover';
 import * as React_2 from 'react';
+import { ReactStore } from '@base-ui/utils/store';
+import { Rect } from '@floating-ui/utils';
+import { Timeout } from '@base-ui/utils/useTimeout';
+import { TransitionStatus as TransitionStatus_2 } from '../../internals/useTransitionStatus.js';
+import type { UseFloatingReturn } from '@floating-ui/react-dom';
+import { VirtualElement } from '@floating-ui/react-dom';
+
+declare type Align = 'start' | 'center' | 'end';
+
+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 type Boundary = 'clipping-ancestors' | Element | Element[] | Rect;
+
+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";
+
+declare type CollisionAvoidance = SideFlipMode | SideShiftMode;
+
+/**
+ * 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<PopoverRoot.ChangeEventDetails> & {
+    readonly popupRef: React_2.RefObject<HTMLElement | null>;
+    readonly backdropRef: React_2.RefObject<HTMLDivElement | null>;
+    readonly internalBackdropRef: React_2.RefObject<HTMLDivElement | null>;
+    readonly triggerFocusTargetRef: React_2.RefObject<HTMLElement | null>;
+    readonly beforeContentFocusGuardRef: React_2.RefObject<HTMLElement | null>;
+    readonly stickIfOpenTimeout: Timeout;
+};
+
+declare interface ContextData {
+    openEvent?: Event | undefined;
+    floatingContext?: FloatingContext | undefined;
+    [key: string]: any;
+}
+
+/**
+ * Creates a new handle to connect a Popover.Root with detached Popover.Trigger components.
+ */
+declare function createPopoverHandle<Payload>(): PopoverHandle<Payload>;
+
+declare const decrementPress: "decrement-press";
+
+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 type OffsetFunction = (data: {
+    side: Side;
+    align: Align;
+    anchor: {
+        width: number;
+        height: number;
+    };
+    positioner: {
+        width: number;
+        height: number;
+    };
+}) => number;
+
+declare const outsidePress: "outside-press";
+
+declare type PayloadChildRenderFunction<Payload> = (arg: {
+    payload: Payload | undefined;
+}) => React_2.ReactNode;
+
+declare const pointer: "pointer";
 
 export declare const Popover: {
-    Positioner: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<PopoverPositionerProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Positioner: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<PopoverPositionerProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Popup: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<PopoverPopupProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Popup: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<PopoverPopupProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Arrow: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<PopoverArrowProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Arrow: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<PopoverArrowProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Backdrop: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<PopoverBackdropProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Backdrop: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<PopoverBackdropProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Title: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<PopoverTitleProps, "ref"> & React_2.RefAttributes<HTMLHeadingElement>, "ref">, "className"> & {
+    Title: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<PopoverTitleProps_2, "ref"> & React_2.RefAttributes<HTMLHeadingElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLHeadingElement>>;
-    Description: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<PopoverDescriptionProps, "ref"> & React_2.RefAttributes<HTMLParagraphElement>, "ref">, "className"> & {
+    Description: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<PopoverDescriptionProps_2, "ref"> & React_2.RefAttributes<HTMLParagraphElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLParagraphElement>>;
-    Close: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<PopoverCloseProps, "ref"> & React_2.RefAttributes<HTMLButtonElement>, "ref">, "className"> & {
+    Close: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<PopoverCloseProps_2, "ref"> & React_2.RefAttributes<HTMLButtonElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLButtonElement>>;
     Viewport: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<Popover_2.Viewport.Props, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
@@ -37,18 +349,1341 @@ export declare const Popover: {
     } & React_2.RefAttributes<HTMLDivElement>>;
     Root: typeof Popover_2.Root;
     Trigger: typeof Trigger;
-    Portal: React_2.ForwardRefExoticComponent<Omit<PopoverPortalProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+    Portal: React_2.ForwardRefExoticComponent<Omit<PopoverPortalProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
     Handle: typeof Popover_2.Handle;
     createHandle: typeof Popover_2.createHandle;
 };
 
+export declare namespace Popover_2 {
+    export {
+        PopoverRoot as Root,
+        PopoverTrigger as Trigger,
+        PopoverPortal as Portal,
+        PopoverPositioner as Positioner,
+        PopoverPopup as Popup,
+        PopoverArrow as Arrow,
+        PopoverBackdrop as Backdrop,
+        PopoverTitle as Title,
+        PopoverDescription as Description,
+        PopoverClose as Close,
+        PopoverViewport as Viewport,
+        createPopoverHandle as createHandle,
+        PopoverHandle as Handle
+    }
+}
+
+/**
+ * Displays an element positioned against the popover anchor.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Popover](https://base-ui.com/react/components/popover)
+ */
+export declare const PopoverArrow: React_2.ForwardRefExoticComponent<Omit<PopoverArrowProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace PopoverArrow {
+    export type State = PopoverArrowState;
+    export type Props = PopoverArrowProps;
+}
+
+export declare interface PopoverArrowProps extends BaseUIComponentProps<'div', PopoverArrowState> {}
+
+export declare interface PopoverArrowState {
+    /**
+     * Whether the popover is currently open.
+     */
+    open: boolean;
+    /**
+     * The side of the anchor the component is placed on.
+     */
+    side: Side;
+    /**
+     * The alignment of the component relative to the anchor.
+     */
+    align: Align;
+    /**
+     * Whether the arrow cannot be centered on the anchor.
+     */
+    uncentered: boolean;
+}
+
+/**
+ * An overlay displayed beneath the popover.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Popover](https://base-ui.com/react/components/popover)
+ */
+export declare const PopoverBackdrop: React_2.ForwardRefExoticComponent<Omit<PopoverBackdropProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace PopoverBackdrop {
+    export type State = PopoverBackdropState;
+    export type Props = PopoverBackdropProps;
+}
+
+export declare interface PopoverBackdropProps extends BaseUIComponentProps<'div', PopoverBackdropState> {}
+
+export declare interface PopoverBackdropState {
+    /**
+     * Whether the popover is currently open.
+     */
+    open: boolean;
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+}
+
+/**
+ * A button that closes the popover.
+ * Renders a `<button>` element.
+ *
+ * Documentation: [Base UI Popover](https://base-ui.com/react/components/popover)
+ */
+export declare const PopoverClose: React_2.ForwardRefExoticComponent<Omit<PopoverCloseProps, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare namespace PopoverClose {
+    export type State = PopoverCloseState;
+    export type Props = PopoverCloseProps;
+}
+
+export declare interface PopoverCloseProps extends NativeButtonProps, BaseUIComponentProps<'button', PopoverCloseState> {}
+
+export declare interface PopoverCloseState {}
+
+/**
+ * A paragraph with additional information about the popover.
+ * Renders a `<p>` element.
+ *
+ * Documentation: [Base UI Popover](https://base-ui.com/react/components/popover)
+ */
+export declare const PopoverDescription: React_2.ForwardRefExoticComponent<Omit<PopoverDescriptionProps, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;
+
+export declare namespace PopoverDescription {
+    export type State = PopoverDescriptionState;
+    export type Props = PopoverDescriptionProps;
+}
+
+export declare interface PopoverDescriptionProps extends BaseUIComponentProps<'p', PopoverDescriptionState> {}
+
+export declare interface PopoverDescriptionState {}
+
+declare class PopoverHandle<Payload> {
+    /**
+     * Internal store holding the popover's state.
+     * @internal
+     */
+    readonly store: PopoverStore<Payload>;
+    constructor();
+    /**
+     * Opens the popover and associates it with the trigger with the given id.
+     * The trigger must be a Popover.Trigger component with this handle passed as a prop.
+     *
+     * @param triggerId ID of the trigger to associate with the popover.
+     */
+    open(triggerId: string): void;
+    /**
+     * Closes the popover.
+     */
+    close(): void;
+    /**
+     * Indicates whether the popover is currently open.
+     */
+    get isOpen(): boolean;
+}
+
+/**
+ * A container for the popover contents.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Popover](https://base-ui.com/react/components/popover)
+ */
+export declare const PopoverPopup: React_2.ForwardRefExoticComponent<Omit<PopoverPopupProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace PopoverPopup {
+    export type State = PopoverPopupState;
+    export type Props = PopoverPopupProps;
+}
+
+export declare interface PopoverPopupProps extends BaseUIComponentProps<'div', PopoverPopupState> {
+    /**
+     * Determines the element to focus when the popover 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) => void | boolean | HTMLElement | null) | undefined;
+    /**
+     * Determines the element to focus when the popover 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) => void | boolean | HTMLElement | null) | undefined;
+}
+
+export declare interface PopoverPopupState {
+    /**
+     * Whether the popover is currently open.
+     */
+    open: boolean;
+    /**
+     * The side of the anchor the component is placed on.
+     */
+    side: Side;
+    /**
+     * The alignment of the component relative to the anchor.
+     */
+    align: Align;
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+    /**
+     * Whether transitions should be skipped.
+     */
+    instant: 'dismiss' | 'click' | 'focus' | 'trigger-change' | undefined;
+}
+
+/**
+ * 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 Popover](https://base-ui.com/react/components/popover)
+ */
+export declare const PopoverPortal: React_2.ForwardRefExoticComponent<Omit<PopoverPortalProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace PopoverPortal {
+    export type State = PopoverPortalState;
+    export type Props = PopoverPortalProps;
+}
+
+export declare interface PopoverPortalProps extends FloatingPortal.Props<PopoverPortalState> {
+    /**
+     * Whether to keep the portal mounted in the DOM while the popup is hidden.
+     * @default false
+     */
+    keepMounted?: boolean | undefined;
+}
+
+export declare interface PopoverPortalState {}
+
+/**
+ * Positions the popover against the trigger.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Popover](https://base-ui.com/react/components/popover)
+ */
+export declare const PopoverPositioner: React_2.ForwardRefExoticComponent<Omit<PopoverPositionerProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace PopoverPositioner {
+    export type State = PopoverPositionerState;
+    export type Props = PopoverPositionerProps;
+}
+
+export declare interface PopoverPositionerProps extends UseAnchorPositioningSharedParameters, BaseUIComponentProps<'div', PopoverPositionerState> {}
+
+export declare interface PopoverPositionerState {
+    /**
+     * Whether the popover is currently open.
+     */
+    open: boolean;
+    /**
+     * The side of the anchor the component is placed on.
+     */
+    side: Side;
+    /**
+     * The alignment of the component relative to the anchor.
+     */
+    align: Align;
+    /**
+     * Whether the anchor element is hidden.
+     */
+    anchorHidden: boolean;
+    /**
+     * Whether CSS transitions should be disabled.
+     */
+    instant: string | undefined;
+}
+
+/**
+ * Groups all parts of the popover.
+ * Doesn't render its own HTML element.
+ *
+ * Documentation: [Base UI Popover](https://base-ui.com/react/components/popover)
+ */
+export declare function PopoverRoot<Payload = unknown>(props: PopoverRoot.Props<Payload>): JSX_2.Element;
+
+export declare namespace PopoverRoot {
+    export type State = PopoverRootState;
+    export type Props<Payload = unknown> = PopoverRootProps<Payload>;
+    export type Actions = PopoverRootActions;
+    export type ChangeEventReason = PopoverRootChangeEventReason;
+    export type ChangeEventDetails = PopoverRootChangeEventDetails;
+}
+
+export declare interface PopoverRootActions {
+    unmount: () => void;
+    close: () => void;
+}
+
+export declare type PopoverRootChangeEventDetails = BaseUIChangeEventDetails<PopoverRoot.ChangeEventReason> & {
+    preventUnmountOnClose(): void;
+};
+
+export declare type PopoverRootChangeEventReason = typeof REASONS.triggerHover | typeof REASONS.triggerFocus | typeof REASONS.triggerPress | typeof REASONS.outsidePress | typeof REASONS.escapeKey | typeof REASONS.closePress | typeof REASONS.focusOut | typeof REASONS.imperativeAction | typeof REASONS.none;
+
+export declare interface PopoverRootProps<Payload = unknown> {
+    /**
+     * Whether the popover is initially open.
+     *
+     * To render a controlled popover, use the `open` prop instead.
+     * @default false
+     */
+    defaultOpen?: boolean | undefined;
+    /**
+     * Whether the popover is currently open.
+     */
+    open?: boolean | undefined;
+    /**
+     * Event handler called when the popover is opened or closed.
+     */
+    onOpenChange?: ((open: boolean, eventDetails: PopoverRoot.ChangeEventDetails) => void) | undefined;
+    /**
+     * Event handler called after any animations complete when the popover is opened or closed.
+     */
+    onOpenChangeComplete?: ((open: boolean) => void) | undefined;
+    /**
+     * A ref to imperative actions.
+     * - `unmount`: When specified, the popover will not be unmounted when closed.
+     * Instead, the `unmount` function must be called to unmount the popover manually.
+     * Useful when the popover's animation is controlled by an external library.
+     * - `close`: Closes the popover imperatively when called.
+     */
+    actionsRef?: React_2.RefObject<PopoverRoot.Actions | null> | undefined;
+    /**
+     * Determines if the popover enters a modal state when open.
+     * - `true`: user interaction is limited to the popover: 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 popover, but document page scroll is not locked and pointer interactions outside of it remain enabled.
+     *
+     * When `modal` is `true`, focus trapping is enabled only if `<Popover.Close>` is rendered
+     * inside `<Popover.Popup>`. It can be visually hidden with your own CSS if needed, such as
+     * Tailwind's `sr-only` utility.
+     *
+     * When `modal` is `'trap-focus'`, render `<Popover.Close>` inside `<Popover.Popup>` so touch
+     * screen readers can escape the popup.
+     * @default false
+     */
+    modal?: boolean | 'trap-focus' | undefined;
+    /**
+     * ID of the trigger that the popover is associated with.
+     * This is useful in conjunction with the `open` prop to create a controlled popover.
+     * There's no need to specify this prop when the popover is uncontrolled (that is, when the `open` prop is not set).
+     */
+    triggerId?: string | null | undefined;
+    /**
+     * ID of the trigger that the popover is associated with.
+     * This is useful in conjunction with the `defaultOpen` prop to create an initially open popover.
+     */
+    defaultTriggerId?: string | null | undefined;
+    /**
+     * A handle to associate the popover with a trigger.
+     * If specified, allows external triggers to control the popover's open state.
+     */
+    handle?: PopoverHandle<Payload> | undefined;
+    /**
+     * The content of the popover.
+     * 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>;
+}
+
+export declare interface PopoverRootState {}
+
+declare class PopoverStore<Payload> extends ReactStore<Readonly<State<Payload>>, Context, Selectors> {
+    constructor(initialState?: Partial<State<Payload>>, floatingId?: string | undefined, nested?: boolean);
+    setOpen: (nextOpen: boolean, eventDetails: Omit<PopoverRoot.ChangeEventDetails, "preventUnmountOnClose">) => void;
+    static useStore<Payload>(externalStore: PopoverStore<Payload> | undefined, initialState: Partial<State<Payload>>): PopoverStore<Payload>;
+    private disposeEffect;
+}
+
+/**
+ * A heading that labels the popover.
+ * Renders an `<h2>` element.
+ *
+ * Documentation: [Base UI Popover](https://base-ui.com/react/components/popover)
+ */
+export declare const PopoverTitle: React_2.ForwardRefExoticComponent<Omit<PopoverTitleProps, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;
+
+export declare namespace PopoverTitle {
+    export type State = PopoverTitleState;
+    export type Props = PopoverTitleProps;
+}
+
+export declare interface PopoverTitleProps extends BaseUIComponentProps<'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6', PopoverTitleState> {}
+
+export declare interface PopoverTitleState {}
+
+/**
+ * A button that opens the popover.
+ * Renders a `<button>` element.
+ *
+ * Documentation: [Base UI Popover](https://base-ui.com/react/components/popover)
+ */
+export declare const PopoverTrigger: PopoverTrigger;
+
+export declare interface PopoverTrigger {
+    <Payload>(componentProps: PopoverTriggerProps<Payload> & React_2.RefAttributes<HTMLElement>): React_2.JSX.Element;
+}
+
+export declare namespace PopoverTrigger {
+    export type State = PopoverTriggerState;
+    export type Props<Payload = unknown> = PopoverTriggerProps<Payload>;
+}
+
+export declare type PopoverTriggerProps<Payload = unknown> = NativeButtonProps & BaseUIComponentProps<'button', PopoverTriggerState> & {
+    /**
+     * 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 (e.g. `<div>`).
+     * @default true
+     */
+    nativeButton?: boolean | undefined;
+    /**
+     * A handle to associate the trigger with a popover.
+     */
+    handle?: PopoverHandle<Payload> | undefined;
+    /**
+     * A payload to pass to the popover 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 popover in controlled mode (with the PopoverRoot `triggerId` prop).
+     */
+    id?: string | undefined;
+    /**
+     * Whether the popover should also open when the trigger is hovered.
+     * @default false
+     */
+    openOnHover?: boolean | undefined;
+    /**
+     * How long to wait before the popover may be opened on hover. Specified in milliseconds.
+     *
+     * Requires the `openOnHover` prop.
+     * @default 300
+     */
+    delay?: number | undefined;
+    /**
+     * How long to wait before closing the popover that was opened on hover.
+     * Specified in milliseconds.
+     *
+     * Requires the `openOnHover` prop.
+     * @default 0
+     */
+    closeDelay?: number | undefined;
+};
+
+export declare interface PopoverTriggerState {
+    /**
+     * Whether the popover is currently disabled.
+     */
+    disabled: boolean;
+    /**
+     * Whether the popover is currently open.
+     */
+    open: boolean;
+}
+
+/**
+ * A viewport for displaying content transitions.
+ * This component is only required if one popup can be opened by multiple triggers, its content
+ * changes based on the trigger, and switching between them is animated.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Popover](https://base-ui.com/react/components/popover)
+ */
+export declare const PopoverViewport: React_2.ForwardRefExoticComponent<Omit<PopoverViewport.Props, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace PopoverViewport {
+    export interface Props extends BaseUIComponentProps<'div', PopoverViewportState> {
+        /**
+         * The content to render inside the transition container.
+         */
+        children?: React_2.ReactNode;
+    }
+    export type State = PopoverViewportState;
+}
+
+export declare interface PopoverViewportState {
+    /**
+     * The activation direction of the transitioned content.
+     */
+    activationDirection: string | undefined;
+    /**
+     * Whether the viewport is currently transitioning between contents.
+     */
+    transitioning: boolean;
+    /**
+     * Present if animations should be instant.
+     */
+    instant: 'dismiss' | 'click' | 'focus' | 'trigger-change' | undefined;
+}
+
+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 type Selectors = typeof selectors_2;
+
+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: {
+    disabled: (state: State<unknown>) => boolean;
+    instantType: (state: State<unknown>) => "click" | "focus" | "dismiss" | "trigger-change" | undefined;
+    openMethod: (state: State<unknown>) => InteractionType | null;
+    openChangeReason: (state: State<unknown>) => PopoverRootChangeEventReason_2 | null;
+    modal: (state: State<unknown>) => boolean | "trap-focus";
+    focusManagerModal: (state: State<unknown>) => boolean;
+    stickIfOpen: (state: State<unknown>) => boolean;
+    titleElementId: (state: State<unknown>) => string | undefined;
+    descriptionElementId: (state: State<unknown>) => string | undefined;
+    openOnHover: (state: State<unknown>) => boolean;
+    closeDelay: (state: State<unknown>) => number;
+    hasViewport: (state: State<unknown>) => boolean;
+    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 Side = 'top' | 'bottom' | 'left' | 'right' | 'inline-end' | 'inline-start';
+
+declare interface SideFlipMode {
+    /**
+     * How to avoid collisions on the side axis.
+     * - `'flip'`: If there is not enough space, place the popup on the opposite side.
+     * - `'none'`: Keep the preferred side even if it overflows.
+     */
+    side?: 'flip' | 'none' | undefined;
+    /**
+     * How to avoid collisions on the align axis.
+     * - `'flip'`: If there is not enough space, swap `'start'` and `'end'` alignment.
+     * - `'shift'`: Keep the alignment and shift the popup to fit within the boundary.
+     * - `'none'`: Keep the preferred alignment even if it overflows.
+     */
+    align?: 'flip' | 'shift' | 'none' | undefined;
+    /**
+     * If both sides on the preferred axis do not fit, determines whether to fallback
+     * to a side on the perpendicular axis and which logical side to prefer.
+     * - `'start'`: Prefer the logical start side on the perpendicular axis.
+     * - `'end'`: Prefer the logical end side on the perpendicular axis.
+     * - `'none'`: Do not fallback to the perpendicular axis.
+     */
+    fallbackAxisSide?: 'start' | 'end' | 'none' | undefined;
+}
+
+declare interface SideShiftMode {
+    /**
+     * How to avoid collisions on the side axis.
+     * - `'shift'`: Keep the preferred side and shift the popup to fit within the boundary.
+     * - `'none'`: Keep the preferred side even if it overflows.
+     */
+    side?: 'shift' | 'none' | undefined;
+    /**
+     * How to avoid collisions on the align axis.
+     * - `'shift'`: Keep the alignment and shift the popup to fit within the boundary.
+     * - `'none'`: Keep the preferred alignment even if it overflows.
+     */
+    align?: 'shift' | 'none' | undefined;
+    /**
+     * If both sides on the preferred axis do not fit, determines whether to fallback
+     * to a side on the perpendicular axis and which logical side to prefer.
+     * - `'start'`: Prefer the logical start side on the perpendicular axis.
+     * - `'end'`: Prefer the logical end side on the perpendicular axis.
+     * - `'none'`: Do not fallback to the perpendicular axis.
+     */
+    fallbackAxisSide?: 'start' | 'end' | 'none' | undefined;
+}
+
+declare type State<Payload> = PopupStoreState<Payload> & {
+    disabled: boolean;
+    instantType: 'dismiss' | 'click' | 'focus' | 'trigger-change' | undefined;
+    modal: boolean | 'trap-focus';
+    focusManagerModal: boolean;
+    openMethod: InteractionType | null;
+    openChangeReason: PopoverRoot.ChangeEventReason | null;
+    stickIfOpen: boolean;
+    nested: boolean;
+    titleElementId: string | undefined;
+    descriptionElementId: string | undefined;
+    openOnHover: boolean;
+    closeDelay: number;
+    hasViewport: boolean;
+};
+
+declare const swipe: "swipe";
+
+declare const trackPress: "track-press";
+
+declare type TransitionStatus = 'starting' | 'ending' | 'idle' | undefined;
+
 declare function Trigger<Payload = unknown>({ className, ...props }: WithStringClassName<Popover_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 UseAnchorPositioningSharedParameters {
+    /**
+     * An element to position the popup against.
+     * By default, the popup will be positioned against the trigger.
+     */
+    anchor?: Element | null | VirtualElement | React_2.RefObject<Element | null> | (() => Element | VirtualElement | null) | undefined;
+    /**
+     * Determines which CSS `position` property to use.
+     * @default 'absolute'
+     */
+    positionMethod?: 'absolute' | 'fixed' | undefined;
+    /**
+     * Which side of the anchor element to align the popup against.
+     * May automatically change to avoid collisions.
+     * @default 'bottom'
+     */
+    side?: Side | undefined;
+    /**
+     * Distance between the anchor and the popup in pixels.
+     * Also accepts a function that returns the distance to read the dimensions of the anchor
+     * and positioner elements, along with its side and alignment.
+     *
+     * The function takes a `data` object parameter with the following properties:
+     * - `data.anchor`: the dimensions of the anchor element with properties `width` and `height`.
+     * - `data.positioner`: the dimensions of the positioner element with properties `width` and `height`.
+     * - `data.side`: which side of the anchor element the positioner is aligned against.
+     * - `data.align`: how the positioner is aligned relative to the specified side.
+     *
+     * @example
+     * ```jsx
+     * <Positioner
+     *   sideOffset={({ side, align, anchor, positioner }) => {
+     *     return side === 'top' || side === 'bottom'
+     *       ? anchor.height
+     *       : anchor.width;
+     *   }}
+     * />
+     * ```
+     *
+     * @default 0
+     */
+    sideOffset?: number | OffsetFunction | undefined;
+    /**
+     * How to align the popup relative to the specified side.
+     * @default 'center'
+     */
+    align?: Align | undefined;
+    /**
+     * Additional offset along the alignment axis in pixels.
+     * Also accepts a function that returns the offset to read the dimensions of the anchor
+     * and positioner elements, along with its side and alignment.
+     *
+     * The function takes a `data` object parameter with the following properties:
+     * - `data.anchor`: the dimensions of the anchor element with properties `width` and `height`.
+     * - `data.positioner`: the dimensions of the positioner element with properties `width` and `height`.
+     * - `data.side`: which side of the anchor element the positioner is aligned against.
+     * - `data.align`: how the positioner is aligned relative to the specified side.
+     *
+     * @example
+     * ```jsx
+     * <Positioner
+     *   alignOffset={({ side, align, anchor, positioner }) => {
+     *     return side === 'top' || side === 'bottom'
+     *       ? anchor.width
+     *       : anchor.height;
+     *   }}
+     * />
+     * ```
+     *
+     * @default 0
+     */
+    alignOffset?: number | OffsetFunction | undefined;
+    /**
+     * An element or a rectangle that delimits the area that the popup is confined to.
+     * @default 'clipping-ancestors'
+     */
+    collisionBoundary?: Boundary | undefined;
+    /**
+     * Additional space to maintain from the edge of the collision boundary.
+     * @default 5
+     */
+    collisionPadding?: Padding | undefined;
+    /**
+     * Whether to maintain the popup in the viewport after
+     * the anchor element was scrolled out of view.
+     * @default false
+     */
+    sticky?: boolean | undefined;
+    /**
+     * Minimum distance to maintain between the arrow and the edges of the popup.
+     *
+     * Use it to prevent the arrow element from hanging out of the rounded corners of a popup.
+     * @default 5
+     */
+    arrowPadding?: number | undefined;
+    /**
+     * Whether to disable the popup from tracking any layout shift of its positioning anchor.
+     * @default false
+     */
+    disableAnchorTracking?: boolean | undefined;
+    /**
+     * Determines how to handle collisions when positioning the popup.
+     *
+     * `side` controls overflow on the preferred placement axis (`top`/`bottom` or `left`/`right`):
+     * - `'flip'`: keep the requested side when it fits; otherwise try the opposite side
+     *   (`top` and `bottom`, or `left` and `right`).
+     * - `'shift'`: never change side; keep the requested side and move the popup within
+     *   the clipping boundary so it stays visible.
+     * - `'none'`: do not correct side-axis overflow.
+     *
+     * `align` controls overflow on the alignment axis (`start`/`center`/`end`):
+     * - `'flip'`: keep side, but swap `start` and `end` when the requested alignment overflows.
+     * - `'shift'`: keep side and requested alignment, then nudge the popup along the
+     *   alignment axis to fit.
+     * - `'none'`: do not correct alignment-axis overflow.
+     *
+     * `fallbackAxisSide` controls fallback behavior on the perpendicular axis when the
+     * preferred axis cannot fit:
+     * - `'start'`: allow perpendicular fallback and try the logical start side first
+     *   (`top` before `bottom`, or `left` before `right` in LTR).
+     * - `'end'`: allow perpendicular fallback and try the logical end side first
+     *   (`bottom` before `top`, or `right` before `left` in LTR).
+     * - `'none'`: do not fallback to the perpendicular axis.
+     *
+     * When `side` is `'shift'`, explicitly setting `align` only supports `'shift'` or `'none'`.
+     * If `align` is omitted, it defaults to `'flip'`.
+     *
+     * @example
+     * ```jsx
+     * <Positioner
+     *   collisionAvoidance={{
+     *     side: 'shift',
+     *     align: 'shift',
+     *     fallbackAxisSide: 'none',
+     *   }}
+     * />
+     * ```
+     *
+     */
+    collisionAvoidance?: CollisionAvoidance | undefined;
+}
+
+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/popover";
-
 export { }