@wix/site-ui 1.29.0 → 1.31.0

package/dist/Menubar/index.d.ts

@@ -1,11 +1,2309 @@
-import { MenubarProps } from '@base-ui/react/menubar';
+import { FloatingRootContext as FloatingRootContext_2 } from '../../floating-ui-react/index.js';
+import { FloatingRootStore as FloatingRootStore_2 } from '../../floating-ui-react/components/FloatingRootStore.js';
+import type { InteractionType } from '@base-ui/utils/useEnhancedClickHandler';
+import { JSX as JSX_2 } from 'react/jsx-runtime';
+import { MenubarProps as MenubarProps_2 } from '@base-ui/react/menubar';
+import { MenuRootChangeEventReason } from '../index.js';
+import { Padding } from '@floating-ui/react-dom';
 import * as React_2 from 'react';
+import { ReactStore } from '@base-ui/utils/store';
+import { Rect } from '@floating-ui/utils';
+import { TransitionStatus as TransitionStatus_2 } from '../../internals/useTransitionStatus.js';
+import type { UseFloatingReturn } from '@floating-ui/react-dom';
+import { VirtualElement } from '@floating-ui/react-dom';
 
-export declare const Menubar: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<MenubarProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+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<MenuRoot.ChangeEventDetails> & {
+    readonly positionerRef: React_2.RefObject<HTMLElement | null>;
+    readonly popupRef: React_2.RefObject<HTMLElement | null>;
+    readonly typingRef: React_2.RefObject<boolean>;
+    readonly itemDomElements: React_2.RefObject<(HTMLElement | null)[]>;
+    readonly itemLabels: React_2.RefObject<(string | null)[]>;
+    allowMouseUpTriggerRef: React_2.RefObject<boolean>;
+    readonly triggerFocusTargetRef: React_2.RefObject<HTMLElement | null>;
+    readonly beforeContentFocusGuardRef: React_2.RefObject<HTMLElement | null>;
+};
+
+declare interface ContextData {
+    openEvent?: Event | undefined;
+    floatingContext?: FloatingContext | undefined;
+    [key: string]: any;
+}
+
+/**
+ * A component that creates a context menu activated by right clicking or long pressing.
+ * Doesn't render its own HTML element.
+ *
+ * Documentation: [Base UI Context Menu](https://base-ui.com/react/components/context-menu)
+ */
+declare function ContextMenuRoot(props: ContextMenuRoot.Props): JSX_2.Element;
+
+declare namespace ContextMenuRoot {
+    type State = ContextMenuRootState;
+    type Props = ContextMenuRootProps;
+    type Actions = ContextMenuRootActions;
+    type ChangeEventReason = ContextMenuRootChangeEventReason;
+    type ChangeEventDetails = ContextMenuRootChangeEventDetails;
+}
+
+declare type ContextMenuRootActions = MenuRoot.Actions;
+
+declare type ContextMenuRootChangeEventDetails = BaseUIChangeEventDetails<ContextMenuRoot.ChangeEventReason>;
+
+declare type ContextMenuRootChangeEventReason = MenuRoot.ChangeEventReason;
+
+declare interface ContextMenuRootContext {
+    anchor: {
+        getBoundingClientRect: () => DOMRect;
+    };
+    setAnchor: React_2.Dispatch<React_2.SetStateAction<ContextMenuRootContext['anchor']>>;
+    backdropRef: React_2.RefObject<HTMLDivElement | null>;
+    internalBackdropRef: React_2.RefObject<HTMLDivElement | null>;
+    actionsRef: React_2.RefObject<{
+        setOpen: (nextOpen: boolean, eventDetails: ContextMenuRoot.ChangeEventDetails) => void;
+    } | null>;
+    positionerRef: React_2.RefObject<HTMLElement | null>;
+    allowMouseUpTriggerRef: React_2.RefObject<boolean>;
+    initialCursorPointRef: React_2.RefObject<{
+        x: number;
+        y: number;
+    } | null>;
+    rootId: string | undefined;
+}
+
+declare const ContextMenuRootContext: React_2.Context<ContextMenuRootContext | undefined>;
+
+declare interface ContextMenuRootProps extends Omit<Menu.Root.Props, 'modal' | 'openOnHover' | 'delay' | 'closeDelay' | 'onOpenChange'> {
+    /**
+     * Event handler called when the menu is opened or closed.
+     */
+    onOpenChange?: ((open: boolean, eventDetails: ContextMenuRoot.ChangeEventDetails) => void) | undefined;
+}
+
+declare interface ContextMenuRootState {}
+
+/**
+ * Creates a new handle to connect a Menu.Root with detached Menu.Trigger components.
+ */
+declare function createMenuHandle<Payload>(): MenuHandle<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;
+}
+
+declare interface FloatingNodeType {
+    id: string | undefined;
+    parentId: string | null;
+    context?: FloatingContext | undefined;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Stores and manages floating elements in a tree structure.
+ * This is a backing store for the `FloatingTree` component.
+ */
+declare class FloatingTreeStore {
+    readonly nodesRef: React.RefObject<Array<FloatingNodeType>>;
+    readonly events: FloatingEvents;
+    addNode(node: FloatingNodeType): void;
+    removeNode(node: FloatingNodeType): void;
+}
+
+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";
+
+export declare namespace Menu {
+    export {
+        MenuArrow as Arrow,
+        MenuBackdrop as Backdrop,
+        MenuCheckboxItem as CheckboxItem,
+        MenuCheckboxItemIndicator as CheckboxItemIndicator,
+        MenuGroup as Group,
+        MenuGroupLabel as GroupLabel,
+        MenuItem as Item,
+        MenuLinkItem as LinkItem,
+        MenuPopup as Popup,
+        MenuPortal as Portal,
+        MenuPositioner as Positioner,
+        MenuRadioGroup as RadioGroup,
+        MenuRadioItem as RadioItem,
+        MenuRadioItemIndicator as RadioItemIndicator,
+        MenuRoot as Root,
+        MenuSubmenuRoot as SubmenuRoot,
+        MenuTrigger as Trigger,
+        MenuViewport as Viewport,
+        Separator,
+        MenuSubmenuTrigger as SubmenuTrigger,
+        MenuHandle as Handle,
+        createMenuHandle as createHandle
+    }
+}
+
+/**
+ * Displays an element positioned against the menu anchor.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuArrow: React_2.ForwardRefExoticComponent<Omit<MenuArrowProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace MenuArrow {
+    type State = MenuArrowState;
+    type Props = MenuArrowProps;
+}
+
+declare interface MenuArrowProps extends BaseUIComponentProps<'div', MenuArrowState> {}
+
+declare interface MenuArrowState {
+    /**
+     * Whether the menu 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 menu popup.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuBackdrop: React_2.ForwardRefExoticComponent<Omit<MenuBackdropProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace MenuBackdrop {
+    type State = MenuBackdropState;
+    type Props = MenuBackdropProps;
+}
+
+declare interface MenuBackdropProps extends BaseUIComponentProps<'div', MenuBackdropState> {}
+
+declare interface MenuBackdropState {
+    /**
+     * Whether the menu is currently open.
+     */
+    open: boolean;
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+}
+
+export declare const Menubar: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<MenubarProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
     className?: string | undefined;
 } & React_2.RefAttributes<HTMLDivElement>>;
 
+declare interface MenubarContext {
+    modal: boolean;
+    disabled: boolean;
+    contentElement: HTMLElement | null;
+    setContentElement: (element: HTMLElement | null) => void;
+    hasSubmenuOpen: boolean;
+    setHasSubmenuOpen: (open: boolean) => void;
+    orientation: MenuRoot.Orientation;
+    allowMouseUpTriggerRef: React_2.RefObject<boolean>;
+    rootId: string | undefined;
+}
+
+declare const MenubarContext: React_2.Context<MenubarContext | null>;
+
+export declare interface MenubarProps extends BaseUIComponentProps<'div', MenubarState> {
+    /**
+     * Whether the menubar is modal.
+     * @default true
+     */
+    modal?: boolean | undefined;
+    /**
+     * Whether the whole menubar is disabled.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * The orientation of the menubar.
+     * @default 'horizontal'
+     */
+    orientation?: MenuRoot.Orientation | undefined;
+    /**
+     * Whether to loop keyboard focus back to the first item
+     * when the end of the list is reached while using the arrow keys.
+     * @default true
+     */
+    loopFocus?: boolean | undefined;
+}
+
+export declare interface MenubarState {
+    /**
+     * The orientation of the menubar.
+     */
+    orientation: MenuRoot.Orientation;
+    /**
+     * Whether the menubar is modal.
+     */
+    modal: boolean;
+    /**
+     * Whether any submenu within the menubar is open.
+     */
+    hasSubmenuOpen: boolean;
+}
+
+/**
+ * A menu item that toggles a setting on or off.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuCheckboxItem: React_2.ForwardRefExoticComponent<Omit<MenuCheckboxItemProps, "ref"> & React_2.RefAttributes<HTMLElement>>;
+
+declare namespace MenuCheckboxItem {
+    type State = MenuCheckboxItemState;
+    type Props = MenuCheckboxItemProps;
+    type ChangeEventReason = MenuCheckboxItemChangeEventReason;
+    type ChangeEventDetails = MenuCheckboxItemChangeEventDetails;
+}
+
+declare type MenuCheckboxItemChangeEventDetails = MenuRoot.ChangeEventDetails;
+
+declare type MenuCheckboxItemChangeEventReason = MenuRoot.ChangeEventReason;
+
+/**
+ * Indicates whether the checkbox item is ticked.
+ * Renders a `<span>` element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuCheckboxItemIndicator: React_2.ForwardRefExoticComponent<Omit<MenuCheckboxItemIndicatorProps, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;
+
+declare namespace MenuCheckboxItemIndicator {
+    type Props = MenuCheckboxItemIndicatorProps;
+    type State = MenuCheckboxItemIndicatorState;
+}
+
+declare interface MenuCheckboxItemIndicatorProps extends BaseUIComponentProps<'span', MenuCheckboxItemIndicatorState> {
+    /**
+     * Whether to keep the HTML element in the DOM when the checkbox item is not checked.
+     * @default false
+     */
+    keepMounted?: boolean | undefined;
+}
+
+declare interface MenuCheckboxItemIndicatorState {
+    /**
+     * Whether the checkbox item is currently ticked.
+     */
+    checked: boolean;
+    /**
+     * Whether the component should ignore user interaction.
+     */
+    disabled: boolean;
+    /**
+     * Whether the item is highlighted.
+     */
+    highlighted: boolean;
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+}
+
+declare interface MenuCheckboxItemProps extends NonNativeButtonProps, BaseUIComponentProps<'div', MenuCheckboxItemState> {
+    /**
+     * Whether the checkbox item is currently ticked.
+     *
+     * To render an uncontrolled checkbox item, use the `defaultChecked` prop instead.
+     */
+    checked?: boolean | undefined;
+    /**
+     * Whether the checkbox item is initially ticked.
+     *
+     * To render a controlled checkbox item, use the `checked` prop instead.
+     * @default false
+     */
+    defaultChecked?: boolean | undefined;
+    /**
+     * Event handler called when the checkbox item is ticked or unticked.
+     */
+    onCheckedChange?: ((checked: boolean, eventDetails: MenuCheckboxItem.ChangeEventDetails) => void) | undefined;
+    /**
+     * The click handler for the menu item.
+     */
+    onClick?: BaseUIComponentProps<'div', MenuCheckboxItemState>['onClick'] | undefined;
+    /**
+     * Whether the component should ignore user interaction.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * Overrides the text label to use when the item is matched during keyboard text navigation.
+     */
+    label?: string | undefined;
+    /**
+     * @ignore
+     */
+    id?: string | undefined;
+    /**
+     * Whether to close the menu when the item is clicked.
+     * @default false
+     */
+    closeOnClick?: boolean | undefined;
+}
+
+declare interface MenuCheckboxItemState {
+    /**
+     * Whether the checkbox item should ignore user interaction.
+     */
+    disabled: boolean;
+    /**
+     * Whether the checkbox item is currently highlighted.
+     */
+    highlighted: boolean;
+    /**
+     * Whether the checkbox item is currently ticked.
+     */
+    checked: boolean;
+}
+
+/**
+ * Groups related menu items with the corresponding label.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuGroup: React_2.ForwardRefExoticComponent<Omit<MenuGroupProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace MenuGroup {
+    type Props = MenuGroupProps;
+    type State = MenuGroupState;
+}
+
+/**
+ * An accessible label that is automatically associated with its parent group.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuGroupLabel: React_2.ForwardRefExoticComponent<Omit<MenuGroupLabelProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace MenuGroupLabel {
+    type Props = MenuGroupLabelProps;
+    type State = MenuGroupLabelState;
+}
+
+declare interface MenuGroupLabelProps extends BaseUIComponentProps<'div', MenuGroupLabelState> {}
+
+declare interface MenuGroupLabelState {}
+
+declare interface MenuGroupProps extends BaseUIComponentProps<'div', MenuGroupState> {
+    /**
+     * The content of the component.
+     */
+    children?: React_2.ReactNode;
+}
+
+declare interface MenuGroupState {}
+
+declare class MenuHandle<Payload> {
+    /**
+     * Internal store holding the menu's state.
+     * @internal
+     */
+    readonly store: MenuStore<Payload>;
+    constructor();
+    /**
+     * Opens the menu and associates it with the trigger with the given id.
+     * The trigger must be a Menu.Trigger component with this handle passed as a prop.
+     *
+     * @param triggerId ID of the trigger to associate with the menu.
+     */
+    open(triggerId: string): void;
+    /**
+     * Closes the menu.
+     */
+    close(): void;
+    /**
+     * Indicates whether the menu is currently open.
+     */
+    get isOpen(): boolean;
+}
+
+/**
+ * An individual interactive item in the menu.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuItem: React_2.ForwardRefExoticComponent<Omit<MenuItemProps, "ref"> & React_2.RefAttributes<HTMLElement>>;
+
+declare namespace MenuItem {
+    type State = MenuItemState;
+    type Props = MenuItemProps;
+}
+
+declare interface MenuItemProps extends NonNativeButtonProps, BaseUIComponentProps<'div', MenuItemState> {
+    /**
+     * The click handler for the menu item.
+     */
+    onClick?: BaseUIComponentProps<'div', MenuItemState>['onClick'] | undefined;
+    /**
+     * Whether the component should ignore user interaction.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * Overrides the text label to use when the item is matched during keyboard text navigation.
+     */
+    label?: string | undefined;
+    /**
+     * @ignore
+     */
+    id?: string | undefined;
+    /**
+     * Whether to close the menu when the item is clicked.
+     *
+     * @default true
+     */
+    closeOnClick?: boolean | undefined;
+}
+
+declare interface MenuItemState {
+    /**
+     * Whether the item should ignore user interaction.
+     */
+    disabled: boolean;
+    /**
+     * Whether the item is highlighted.
+     */
+    highlighted: boolean;
+}
+
+/**
+ * A link in the menu that can be used to navigate to a different page or section.
+ * Renders an `<a>` element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuLinkItem: React_2.ForwardRefExoticComponent<Omit<MenuLinkItemProps, "ref"> & React_2.RefAttributes<Element>>;
+
+declare namespace MenuLinkItem {
+    type State = MenuLinkItemState;
+    type Props = MenuLinkItemProps;
+}
+
+declare interface MenuLinkItemProps extends BaseUIComponentProps<'a', MenuLinkItemState> {
+    /**
+     * Overrides the text label to use when the item is matched during keyboard text navigation.
+     */
+    label?: string | undefined;
+    /**
+     * @ignore
+     */
+    id?: string | undefined;
+    /**
+     * Whether to close the menu when the item is clicked.
+     * @default false
+     */
+    closeOnClick?: boolean | undefined;
+}
+
+declare interface MenuLinkItemState {
+    /**
+     * Whether the item is highlighted.
+     */
+    highlighted: boolean;
+}
+
+declare type MenuParent = {
+    type: 'menu';
+    store: MenuStore<unknown>;
+} | {
+    type: 'menubar';
+    context: MenubarContext;
+} | {
+    type: 'context-menu';
+    context: ContextMenuRootContext;
+} | {
+    type: 'nested-context-menu';
+    context: ContextMenuRootContext;
+    menuContext: MenuRootContext;
+} | {
+    type: undefined;
+};
+
+/**
+ * A container for the menu items.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuPopup: React_2.ForwardRefExoticComponent<Omit<MenuPopupProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace MenuPopup {
+    type Props = MenuPopupProps;
+    type State = MenuPopupState;
+}
+
+declare interface MenuPopupProps extends BaseUIComponentProps<'div', MenuPopupState> {
+    children?: React_2.ReactNode;
+    /**
+     * @ignore
+     */
+    id?: string | undefined;
+    /**
+     * Determines the element to focus when the menu 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;
+}
+
+declare interface MenuPopupState {
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+    /**
+     * 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 menu is currently open.
+     */
+    open: boolean;
+    /**
+     * Whether the component is nested.
+     */
+    nested: boolean;
+    /**
+     * Whether transitions should be skipped.
+     */
+    instant: 'dismiss' | 'click' | 'group' | '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 Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuPortal: React_2.ForwardRefExoticComponent<Omit<MenuPortalProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace MenuPortal {
+    type State = MenuPortalState;
+    type Props = MenuPortalProps;
+}
+
+declare interface MenuPortalProps extends FloatingPortal.Props<MenuPortalState> {
+    /**
+     * Whether to keep the portal mounted in the DOM while the popup is hidden.
+     * @default false
+     */
+    keepMounted?: boolean | undefined;
+}
+
+declare interface MenuPortalState {}
+
+/**
+ * Positions the menu popup against the trigger.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuPositioner: React_2.ForwardRefExoticComponent<Omit<MenuPositionerProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace MenuPositioner {
+    type State = MenuPositionerState;
+    type Props = MenuPositionerProps;
+}
+
+declare interface MenuPositionerProps extends UseAnchorPositioningSharedParameters, BaseUIComponentProps<'div', MenuPositionerState> {}
+
+declare interface MenuPositionerState {
+    /**
+     * Whether the menu 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 the component is nested.
+     */
+    nested: boolean;
+    /**
+     * Whether CSS transitions should be disabled.
+     */
+    instant: string | undefined;
+}
+
+/**
+ * Groups related radio items.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuRadioGroup: React_2.NamedExoticComponent<Omit<MenuRadioGroupProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace MenuRadioGroup {
+    type Props = MenuRadioGroupProps;
+    type State = MenuRadioGroupState;
+    type ChangeEventReason = MenuRadioGroupChangeEventReason;
+    type ChangeEventDetails = MenuRadioGroupChangeEventDetails;
+}
+
+declare type MenuRadioGroupChangeEventDetails = MenuRoot.ChangeEventDetails;
+
+declare type MenuRadioGroupChangeEventReason = MenuRoot.ChangeEventReason;
+
+declare interface MenuRadioGroupProps extends BaseUIComponentProps<'div', MenuRadioGroupState> {
+    /**
+     * The content of the component.
+     */
+    children?: React_2.ReactNode;
+    /**
+     * The controlled value of the radio item that should be currently selected.
+     *
+     * To render an uncontrolled radio group, use the `defaultValue` prop instead.
+     */
+    value?: any;
+    /**
+     * The uncontrolled value of the radio item that should be initially selected.
+     *
+     * To render a controlled radio group, use the `value` prop instead.
+     */
+    defaultValue?: any;
+    /**
+     * Function called when the selected value changes.
+     */
+    onValueChange?: ((value: any, eventDetails: MenuRadioGroup.ChangeEventDetails) => void) | undefined;
+    /**
+     * Whether the component should ignore user interaction.
+     *
+     * @default false
+     */
+    disabled?: boolean | undefined;
+}
+
+declare interface MenuRadioGroupState {
+    /**
+     * Whether the component is disabled.
+     */
+    disabled: boolean;
+}
+
+/**
+ * A menu item that works like a radio button in a given group.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuRadioItem: React_2.ForwardRefExoticComponent<Omit<MenuRadioItemProps, "ref"> & React_2.RefAttributes<HTMLElement>>;
+
+declare namespace MenuRadioItem {
+    type State = MenuRadioItemState;
+    type Props = MenuRadioItemProps;
+}
+
+/**
+ * Indicates whether the radio item is selected.
+ * Renders a `<span>` element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuRadioItemIndicator: React_2.ForwardRefExoticComponent<Omit<MenuRadioItemIndicatorProps, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;
+
+declare namespace MenuRadioItemIndicator {
+    type Props = MenuRadioItemIndicatorProps;
+    type State = MenuRadioItemIndicatorState;
+}
+
+declare interface MenuRadioItemIndicatorProps extends BaseUIComponentProps<'span', MenuRadioItemIndicatorState> {
+    /**
+     * Whether to keep the HTML element in the DOM when the radio item is inactive.
+     * @default false
+     */
+    keepMounted?: boolean | undefined;
+}
+
+declare interface MenuRadioItemIndicatorState {
+    /**
+     * Whether the radio item is currently selected.
+     */
+    checked: boolean;
+    /**
+     * Whether the component should ignore user interaction.
+     */
+    disabled: boolean;
+    /**
+     * Whether the item is highlighted.
+     */
+    highlighted: boolean;
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+}
+
+declare interface MenuRadioItemProps extends NonNativeButtonProps, BaseUIComponentProps<'div', MenuRadioItemState> {
+    /**
+     * Value of the radio item.
+     * This is the value that will be set in the MenuRadioGroup when the item is selected.
+     */
+    value: any;
+    /**
+     * The click handler for the menu item.
+     */
+    onClick?: BaseUIComponentProps<'div', MenuRadioItemState>['onClick'] | undefined;
+    /**
+     * Whether the component should ignore user interaction.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * Overrides the text label to use when the item is matched during keyboard text navigation.
+     */
+    label?: string | undefined;
+    /**
+     * @ignore
+     */
+    id?: string | undefined;
+    /**
+     * Whether to close the menu when the item is clicked.
+     * @default false
+     */
+    closeOnClick?: boolean | undefined;
+}
+
+declare interface MenuRadioItemState {
+    /**
+     * Whether the radio item should ignore user interaction.
+     */
+    disabled: boolean;
+    /**
+     * Whether the radio item is currently highlighted.
+     */
+    highlighted: boolean;
+    /**
+     * Whether the radio item is currently selected.
+     */
+    checked: boolean;
+}
+
+/**
+ * Groups all parts of the menu.
+ * Doesn't render its own HTML element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuRoot: <Payload>(props: MenuRoot.Props<Payload>) => JSX_2.Element;
+
+declare namespace MenuRoot {
+    type State = MenuRootState;
+    type Props<Payload = unknown> = MenuRootProps<Payload>;
+    type Actions = MenuRootActions;
+    type ChangeEventReason = MenuRootChangeEventReason_2;
+    type ChangeEventDetails = MenuRootChangeEventDetails;
+    type Orientation = MenuRootOrientation;
+}
+
+declare interface MenuRootActions {
+    unmount: () => void;
+    close: () => void;
+}
+
+declare type MenuRootChangeEventDetails = BaseUIChangeEventDetails<MenuRoot.ChangeEventReason> & {
+    preventUnmountOnClose(): void;
+};
+
+declare type MenuRootChangeEventReason_2 = typeof REASONS.triggerHover | typeof REASONS.triggerFocus | typeof REASONS.triggerPress | typeof REASONS.outsidePress | typeof REASONS.focusOut | typeof REASONS.listNavigation | typeof REASONS.escapeKey | typeof REASONS.itemPress | typeof REASONS.closePress | typeof REASONS.siblingOpen | typeof REASONS.cancelOpen | typeof REASONS.imperativeAction | typeof REASONS.none;
+
+declare interface MenuRootContext<Payload = unknown> {
+    store: MenuStore<Payload>;
+    parent: MenuParent;
+}
+
+declare const MenuRootContext: React_2.Context<MenuRootContext<unknown> | undefined>;
+
+declare type MenuRootOrientation = 'horizontal' | 'vertical';
+
+declare interface MenuRootProps<Payload = unknown> {
+    /**
+     * Whether the menu is initially open.
+     *
+     * To render a controlled menu, use the `open` prop instead.
+     * @default false
+     */
+    defaultOpen?: boolean | undefined;
+    /**
+     * Whether to loop keyboard focus back to the first item
+     * when the end of the list is reached while using the arrow keys.
+     * @default true
+     */
+    loopFocus?: boolean | undefined;
+    /**
+     * Whether moving the pointer over items should highlight them.
+     * Disabling this prop allows CSS `:hover` to be differentiated from the `:focus` (`data-highlighted`) state.
+     * @default true
+     */
+    highlightItemOnHover?: boolean | undefined;
+    /**
+     * Determines if the menu enters a modal state when open.
+     * - `true`: user interaction is limited to the menu: document page scroll is locked and pointer interactions on outside elements are disabled.
+     * - `false`: user interaction with the rest of the document is allowed.
+     * @default true
+     */
+    modal?: boolean | undefined;
+    /**
+     * Event handler called when the menu is opened or closed.
+     */
+    onOpenChange?: ((open: boolean, eventDetails: MenuRoot.ChangeEventDetails) => void) | undefined;
+    /**
+     * Event handler called after any animations complete when the menu is closed.
+     */
+    onOpenChangeComplete?: ((open: boolean) => void) | undefined;
+    /**
+     * Whether the menu is currently open.
+     */
+    open?: boolean | undefined;
+    /**
+     * The visual orientation of the menu.
+     * Controls whether roving focus uses up/down or left/right arrow keys.
+     * @default 'vertical'
+     */
+    orientation?: MenuRoot.Orientation | undefined;
+    /**
+     * Whether the component should ignore user interaction.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * When in a submenu, determines whether pressing the Escape key
+     * closes the entire menu, or only the current child menu.
+     * @default false
+     */
+    closeParentOnEsc?: boolean | undefined;
+    /**
+     * A ref to imperative actions.
+     * - `unmount`: When specified, the menu will not be unmounted when closed.
+     *    Instead, the `unmount` function must be called to unmount the menu manually.
+     *   Useful when the menu's animation is controlled by an external library.
+     * - `close`: When specified, the menu can be closed imperatively.
+     */
+    actionsRef?: React_2.RefObject<MenuRoot.Actions | null> | 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 menu with a trigger.
+     * If specified, allows external triggers to control the menu's open state.
+     */
+    handle?: MenuHandle<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>;
+}
+
+declare interface MenuRootState {}
+
+declare class MenuStore<Payload> extends ReactStore<Readonly<State<Payload>>, Context, typeof selectors_2> {
+    constructor(initialState?: Partial<State<Payload>>);
+    setOpen(open: boolean, eventDetails: Omit<MenuRoot.ChangeEventDetails, 'preventUnmountOnClose'>): void;
+    static useStore<Payload>(externalStore: MenuStore<Payload> | undefined, initialState: Partial<State<Payload>>): MenuStore<Payload>;
+    private unsubscribeParentListener;
+}
+
+/**
+ * Groups all parts of a submenu.
+ * Doesn't render its own HTML element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare function MenuSubmenuRoot(props: MenuSubmenuRoot.Props): JSX_2.Element;
+
+declare namespace MenuSubmenuRoot {
+    type Props = MenuSubmenuRootProps;
+    type State = MenuSubmenuRootState;
+    type ChangeEventReason = MenuSubmenuRootChangeEventReason;
+    type ChangeEventDetails = MenuSubmenuRootChangeEventDetails;
+}
+
+declare type MenuSubmenuRootChangeEventDetails = MenuRoot.ChangeEventDetails;
+
+declare type MenuSubmenuRootChangeEventReason = MenuRoot.ChangeEventReason;
+
+declare interface MenuSubmenuRootProps extends Omit<MenuRoot.Props, 'modal' | 'openOnHover' | 'onOpenChange'> {
+    /**
+     * Event handler called when the menu is opened or closed.
+     */
+    onOpenChange?: ((open: boolean, eventDetails: MenuSubmenuRoot.ChangeEventDetails) => void) | undefined;
+    /**
+     * When in a submenu, determines whether pressing the Escape key
+     * closes the entire menu, or only the current child menu.
+     * @default false
+     */
+    closeParentOnEsc?: boolean | undefined;
+}
+
+declare interface MenuSubmenuRootState {}
+
+/**
+ * A menu item that opens a submenu.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuSubmenuTrigger: React_2.ForwardRefExoticComponent<Omit<MenuSubmenuTriggerProps, "ref"> & React_2.RefAttributes<HTMLElement>>;
+
+declare namespace MenuSubmenuTrigger {
+    type Props = MenuSubmenuTriggerProps;
+    type State = MenuSubmenuTriggerState;
+}
+
+declare interface MenuSubmenuTriggerProps extends NonNativeButtonProps, BaseUIComponentProps<'div', MenuSubmenuTriggerState> {
+    onClick?: BaseUIComponentProps<'div', MenuSubmenuTriggerState>['onClick'] | undefined;
+    /**
+     * Overrides the text label to use when the item is matched during keyboard text navigation.
+     */
+    label?: string | undefined;
+    /**
+     * @ignore
+     */
+    id?: string | undefined;
+    /**
+     * Whether the component should ignore user interaction.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * How long to wait before the menu may be opened on hover. Specified in milliseconds.
+     *
+     * Requires the `openOnHover` prop.
+     * @default 100
+     */
+    delay?: number | undefined;
+    /**
+     * How long to wait before closing the menu that was opened on hover.
+     * Specified in milliseconds.
+     *
+     * Requires the `openOnHover` prop.
+     * @default 0
+     */
+    closeDelay?: number | undefined;
+    /**
+     * Whether the menu should also open when the trigger is hovered.
+     */
+    openOnHover?: boolean | undefined;
+}
+
+declare interface MenuSubmenuTriggerState {
+    /**
+     * Whether the component should ignore user interaction.
+     */
+    disabled: boolean;
+    /**
+     * Whether the item is highlighted.
+     */
+    highlighted: boolean;
+    /**
+     * Whether the menu is currently open.
+     */
+    open: boolean;
+}
+
+/**
+ * A button that opens the menu.
+ * Renders a `<button>` element.
+ *
+ * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuTrigger: MenuTrigger;
+
+declare interface MenuTrigger {
+    <Payload>(componentProps: MenuTriggerProps<Payload> & React_2.RefAttributes<HTMLElement>): React_2.JSX.Element;
+}
+
+declare namespace MenuTrigger {
+    type Props<Payload = unknown> = MenuTriggerProps<Payload>;
+    type State = MenuTriggerState;
+}
+
+declare interface MenuTriggerProps<Payload = unknown> extends NativeButtonProps, BaseUIComponentProps<'button', MenuTriggerState> {
+    children?: React_2.ReactNode;
+    /**
+     * Whether the component should ignore user interaction.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * A handle to associate the trigger with a menu.
+     */
+    handle?: MenuHandle<Payload> | undefined;
+    /**
+     * A payload to pass to the menu when it is opened.
+     */
+    payload?: Payload | undefined;
+    /**
+     * How long to wait before the menu may be opened on hover. Specified in milliseconds.
+     *
+     * Requires the `openOnHover` prop.
+     * @default 100
+     */
+    delay?: number | undefined;
+    /**
+     * How long to wait before closing the menu that was opened on hover.
+     * Specified in milliseconds.
+     *
+     * Requires the `openOnHover` prop.
+     * @default 0
+     */
+    closeDelay?: number | undefined;
+    /**
+     * Whether the menu should also open when the trigger is hovered.
+     */
+    openOnHover?: boolean | undefined;
+}
+
+declare interface MenuTriggerState {
+    /**
+     * Whether the menu is currently open.
+     */
+    open: boolean;
+    /**
+     * Whether the trigger is disabled.
+     */
+    disabled: 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 Menu](https://base-ui.com/react/components/menu)
+ */
+declare const MenuViewport: React_2.ForwardRefExoticComponent<Omit<MenuViewport.Props, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace MenuViewport {
+    interface Props extends BaseUIComponentProps<'div', State> {
+        /**
+         * The content to render inside the transition container.
+         */
+        children?: React_2.ReactNode;
+    }
+    interface State {
+        activationDirection: string | undefined;
+        /**
+         * Whether the viewport is currently transitioning between contents.
+         */
+        transitioning: boolean;
+        /**
+         * Present if animations should be instant.
+         */
+        instant: 'dismiss' | 'click' | 'group' | 'trigger-change' | undefined;
+    }
+}
+
+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 interface NonNativeButtonProps {
+    /**
+     * Whether the component renders a native `<button>` element when replacing it
+     * via the `render` prop.
+     * Set to `true` if the rendered element is a native button.
+     * @default false
+     */
+    nativeButton?: boolean | undefined;
+}
+
+declare type OffsetFunction = (data: {
+    side: Side;
+    align: Align;
+    anchor: {
+        width: number;
+        height: number;
+    };
+    positioner: {
+        width: number;
+        height: number;
+    };
+}) => number;
+
+declare type Orientation = 'horizontal' | 'vertical';
+
+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: {
+    disabled: (state: State<unknown>) => boolean;
+    modal: (state: State<unknown>) => boolean;
+    openMethod: (state: State<unknown>) => InteractionType | null;
+    allowMouseEnter: (state: State<unknown>) => boolean;
+    stickIfOpen: (state: State<unknown>) => boolean;
+    parent: (state: State<unknown>) => MenuParent;
+    rootId: (state: State<unknown>) => string | undefined;
+    activeIndex: (state: State<unknown>) => number | null;
+    isActive: (state: State<unknown>, itemIndex: number) => boolean;
+    hoverEnabled: (state: State<unknown>) => boolean;
+    instantType: (state: State<unknown>) => "group" | "click" | "dismiss" | "trigger-change" | undefined;
+    lastOpenChangeReason: (state: State<unknown>) => MenuRootChangeEventReason | null;
+    floatingTreeRoot: (state: State<unknown>) => FloatingTreeStore;
+    floatingNodeId: (state: State<unknown>) => string | undefined;
+    floatingParentNodeId: (state: State<unknown>) => string | null;
+    itemProps: (state: State<unknown>) => HTMLProps;
+    closeDelay: (state: State<unknown>) => number;
+    hasViewport: (state: State<unknown>) => boolean;
+    keyboardEventRelay: (state: State<unknown>) => React_2.KeyboardEventHandler<any> | undefined;
+    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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }) => 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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }) => 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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }) => 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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }) => 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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }) => 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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }) => 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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }) => 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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }) => 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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }) => 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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }) => 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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }, 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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }, 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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }, 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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }, isActive: boolean) => HTMLProps;
+    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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }, 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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }) => HTMLProps;
+    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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }) => 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;
+        inactiveTriggerProps: HTMLProps;
+        popupProps: HTMLProps;
+    }) => HTMLElement | null;
+};
+
+/**
+ * A separator element accessible to screen readers.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Separator](https://base-ui.com/react/components/separator)
+ */
+declare const Separator: React_2.ForwardRefExoticComponent<Omit<SeparatorProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace Separator {
+    type Props = SeparatorProps;
+    type State = SeparatorState;
+}
+
+declare interface SeparatorProps extends BaseUIComponentProps<'div', SeparatorState> {
+    /**
+     * The orientation of the separator.
+     * @default 'horizontal'
+     */
+    orientation?: Orientation | undefined;
+}
+
+declare interface SeparatorState {
+    /**
+     * The orientation of the separator.
+     */
+    orientation: Orientation;
+}
+
+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;
+    modal: boolean;
+    openMethod: InteractionType | null;
+    allowMouseEnter: boolean;
+    parent: MenuParent;
+    rootId: string | undefined;
+    activeIndex: number | null;
+    hoverEnabled: boolean;
+    stickIfOpen: boolean;
+    instantType: 'dismiss' | 'click' | 'group' | 'trigger-change' | undefined;
+    openChangeReason: MenuRoot.ChangeEventReason | null;
+    floatingTreeRoot: FloatingTreeStore;
+    floatingNodeId: string | undefined;
+    floatingParentNodeId: string | null;
+    itemProps: HTMLProps;
+    closeDelay: number;
+    keyboardEventRelay: ((event: React_2.KeyboardEvent<any>) => void) | undefined;
+    hasViewport: boolean;
+};
+
+declare const swipe: "swipe";
+
+declare const trackPress: "track-press";
+
+declare type TransitionStatus = 'starting' | 'ending' | 'idle' | undefined;
+
+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]> };
 
-export * from "@base-ui/react/menubar";
+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;
 
 export { }