@wix/site-ui 1.30.0 → 1.31.0

package/dist/Breadcrumbs/index.d.ts

@@ -1,19 +1,90 @@
 import { JSX as JSX_2 } from 'react/jsx-runtime';
-import { NavigationMenu } from '@base-ui/react/navigation-menu';
-import { NavigationMenuItemProps } from '@base-ui/react/navigation-menu';
-import { NavigationMenuLinkProps } from '@base-ui/react/navigation-menu';
-import { NavigationMenuListProps } from '@base-ui/react/navigation-menu';
+import { NavigationMenuItemProps as NavigationMenuItemProps_2 } from '@base-ui/react/navigation-menu';
+import { NavigationMenuLinkProps as NavigationMenuLinkProps_2 } from '@base-ui/react/navigation-menu';
+import { NavigationMenuListProps as NavigationMenuListProps_2 } from '@base-ui/react/navigation-menu';
+import { Padding } from '@floating-ui/react-dom';
 import * as React_2 from 'react';
+import { Rect } from '@floating-ui/utils';
+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;
 
 export declare const Breadcrumbs: {
     Root: typeof Root;
-    List: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<NavigationMenuListProps, "ref"> & React_2.RefAttributes<HTMLUListElement>, "ref">, "className"> & {
+    List: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<NavigationMenuListProps_2, "ref"> & React_2.RefAttributes<HTMLUListElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLUListElement>>;
-    Item: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<NavigationMenuItemProps, "ref"> & React_2.RefAttributes<HTMLLIElement>, "ref">, "className"> & {
+    Item: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<NavigationMenuItemProps_2, "ref"> & React_2.RefAttributes<HTMLLIElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLLIElement>>;
-    Link: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<NavigationMenuLinkProps, "ref"> & React_2.RefAttributes<HTMLAnchorElement>, "ref">, "className"> & {
+    Link: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<NavigationMenuLinkProps_2, "ref"> & React_2.RefAttributes<HTMLAnchorElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLAnchorElement>>;
     Page: React_2.ForwardRefExoticComponent<{
@@ -21,10 +92,892 @@ export declare const Breadcrumbs: {
     } & Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;
 };
 
+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 const decrementPress: "decrement-press";
+
+declare const disabled: "disabled";
+
+declare const drag: "drag";
+
+declare const escapeKey: "escape-key";
+
+/**
+ * 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 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 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;
+}
+
+export declare namespace NavigationMenu {
+    export {
+        NavigationMenuRoot as Root,
+        NavigationMenuList as List,
+        NavigationMenuItem as Item,
+        NavigationMenuContent as Content,
+        NavigationMenuTrigger as Trigger,
+        NavigationMenuPortal as Portal,
+        NavigationMenuPositioner as Positioner,
+        NavigationMenuViewport as Viewport,
+        NavigationMenuBackdrop as Backdrop,
+        NavigationMenuPopup as Popup,
+        NavigationMenuArrow as Arrow,
+        NavigationMenuLink as Link,
+        NavigationMenuIcon as Icon
+    }
+}
+
+/**
+ * Displays an element pointing toward the navigation menu's current anchor.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Navigation Menu](https://base-ui.com/react/components/navigation-menu)
+ */
+declare const NavigationMenuArrow: React_2.ForwardRefExoticComponent<Omit<NavigationMenuArrowProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace NavigationMenuArrow {
+    type State = NavigationMenuArrowState;
+    type Props = NavigationMenuArrowProps;
+}
+
+declare interface NavigationMenuArrowProps extends BaseUIComponentProps<'div', NavigationMenuArrowState> {}
+
+declare interface NavigationMenuArrowState {
+    /**
+     * Whether the popup 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;
+}
+
+/**
+ * A backdrop for the navigation menu popup.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Navigation Menu](https://base-ui.com/react/components/navigation-menu)
+ */
+declare const NavigationMenuBackdrop: React_2.ForwardRefExoticComponent<Omit<NavigationMenuBackdropProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace NavigationMenuBackdrop {
+    type State = NavigationMenuBackdropState;
+    type Props = NavigationMenuBackdropProps;
+}
+
+declare interface NavigationMenuBackdropProps extends BaseUIComponentProps<'div', NavigationMenuBackdropState> {}
+
+declare interface NavigationMenuBackdropState {
+    /**
+     * If `true`, the popup is open.
+     */
+    open: boolean;
+    /**
+     * The transition status of the popup.
+     */
+    transitionStatus: TransitionStatus;
+}
+
+/**
+ * A container for the content of the navigation menu item that is moved into the popup
+ * when the item is active.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Navigation Menu](https://base-ui.com/react/components/navigation-menu)
+ */
+declare const NavigationMenuContent: React_2.ForwardRefExoticComponent<Omit<NavigationMenuContentProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace NavigationMenuContent {
+    type State = NavigationMenuContentState;
+    type Props = NavigationMenuContentProps;
+}
+
+declare interface NavigationMenuContentProps extends BaseUIComponentProps<'div', NavigationMenuContentState> {
+    /**
+     * Whether to keep the content mounted in the DOM while the popup is closed.
+     * Ensures the content is present during server-side rendering for web crawlers.
+     * @default false
+     */
+    keepMounted?: boolean | undefined;
+}
+
+declare interface NavigationMenuContentState {
+    /**
+     * If `true`, the component is open.
+     */
+    open: boolean;
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+    /**
+     * The direction of the activation.
+     */
+    activationDirection: 'left' | 'right' | 'up' | 'down' | null;
+}
+
+/**
+ * An icon that indicates that the trigger button opens a menu.
+ *
+ * Documentation: [Base UI Navigation Menu](https://base-ui.com/react/components/navigation-menu)
+ */
+declare const NavigationMenuIcon: React_2.ForwardRefExoticComponent<Omit<NavigationMenuIconProps, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;
+
+declare namespace NavigationMenuIcon {
+    type State = NavigationMenuIconState;
+    type Props = NavigationMenuIconProps;
+}
+
+declare interface NavigationMenuIconProps extends BaseUIComponentProps<'span', NavigationMenuIconState> {}
+
+declare interface NavigationMenuIconState {
+    /**
+     * Whether the navigation menu is open and the item is active.
+     */
+    open: boolean;
+}
+
+/**
+ * An individual navigation menu item.
+ * Renders a `<li>` element.
+ *
+ * Documentation: [Base UI Navigation Menu](https://base-ui.com/react/components/navigation-menu)
+ */
+declare const NavigationMenuItem: React_2.ForwardRefExoticComponent<Omit<NavigationMenuItemProps, "ref"> & React_2.RefAttributes<HTMLLIElement>>;
+
+declare namespace NavigationMenuItem {
+    type State = NavigationMenuItemState;
+    type Props = NavigationMenuItemProps;
+}
+
+declare interface NavigationMenuItemProps extends BaseUIComponentProps<'li', NavigationMenuItemState> {
+    /**
+     * A unique value that identifies this navigation menu item.
+     * If no value is provided, a unique ID will be generated automatically.
+     * Use when controlling the navigation menu programmatically.
+     */
+    value?: any;
+}
+
+declare interface NavigationMenuItemState {}
+
+/**
+ * A link in the navigation menu that can be used to navigate to a different page or section.
+ * Renders an `<a>` element.
+ *
+ * Documentation: [Base UI Navigation Menu](https://base-ui.com/react/components/navigation-menu)
+ */
+declare const NavigationMenuLink: React_2.ForwardRefExoticComponent<Omit<NavigationMenuLinkProps, "ref"> & React_2.RefAttributes<HTMLAnchorElement>>;
+
+declare namespace NavigationMenuLink {
+    type State = NavigationMenuLinkState;
+    type Props = NavigationMenuLinkProps;
+}
+
+declare interface NavigationMenuLinkProps extends BaseUIComponentProps<'a', NavigationMenuLinkState> {
+    /**
+     * Whether the link is the currently active page.
+     * @default false
+     */
+    active?: boolean | undefined;
+    /**
+     * Whether to close the navigation menu when the link is clicked.
+     * @default false
+     */
+    closeOnClick?: boolean | undefined;
+}
+
+declare interface NavigationMenuLinkState {
+    /**
+     * Whether the link is the currently active page.
+     */
+    active: boolean;
+}
+
+/**
+ * Contains a list of navigation menu items.
+ * Renders a `<ul>` element.
+ *
+ * Documentation: [Base UI Navigation Menu](https://base-ui.com/react/components/navigation-menu)
+ */
+declare const NavigationMenuList: React_2.ForwardRefExoticComponent<Omit<NavigationMenuListProps, "ref"> & React_2.RefAttributes<HTMLUListElement>>;
+
+declare namespace NavigationMenuList {
+    type State = NavigationMenuListState;
+    type Props = NavigationMenuListProps;
+}
+
+declare interface NavigationMenuListProps extends BaseUIComponentProps<'ul', NavigationMenuListState> {}
+
+declare interface NavigationMenuListState {
+    /**
+     * If `true`, the popup is open.
+     */
+    open: boolean;
+}
+
+/**
+ * A container for the navigation menu contents.
+ * Renders a `<nav>` element.
+ *
+ * Documentation: [Base UI Navigation Menu](https://base-ui.com/react/components/navigation-menu)
+ */
+declare const NavigationMenuPopup: React_2.ForwardRefExoticComponent<Omit<NavigationMenuPopupProps, "ref"> & React_2.RefAttributes<HTMLElement>>;
+
+declare namespace NavigationMenuPopup {
+    type State = NavigationMenuPopupState;
+    type Props = NavigationMenuPopupProps;
+}
+
+declare interface NavigationMenuPopupProps extends BaseUIComponentProps<'nav', NavigationMenuPopupState> {}
+
+declare interface NavigationMenuPopupState {
+    /**
+     * If `true`, the popup is open.
+     */
+    open: boolean;
+    /**
+     * The transition status of the popup.
+     */
+    transitionStatus: TransitionStatus;
+    /**
+     * The side of the anchor the popup is positioned on.
+     */
+    side: Side;
+    /**
+     * The alignment of the popup relative to the anchor.
+     */
+    align: Align;
+    /**
+     * Whether the anchor element is hidden.
+     */
+    anchorHidden: boolean;
+}
+
+/**
+ * A portal element that moves the popup to a different part of the DOM.
+ * By default, the portal element is appended to `<body>`.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Navigation Menu](https://base-ui.com/react/components/navigation-menu)
+ */
+declare const NavigationMenuPortal: React_2.ForwardRefExoticComponent<Omit<NavigationMenuPortalProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace NavigationMenuPortal {
+    type State = NavigationMenuPortalState;
+    type Props = NavigationMenuPortalProps;
+}
+
+declare interface NavigationMenuPortalProps extends FloatingPortal.Props<NavigationMenuPortalState> {
+    /**
+     * Whether to keep the portal mounted in the DOM while the popup is hidden.
+     * @default false
+     */
+    keepMounted?: boolean | undefined;
+    /**
+     * A parent element to render the portal element into.
+     */
+    container?: FloatingPortal.Props<NavigationMenuPortalState>['container'] | undefined;
+}
+
+declare interface NavigationMenuPortalState {}
+
+/**
+ * Positions the navigation menu against the currently active trigger.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Navigation Menu](https://base-ui.com/react/components/navigation-menu)
+ */
+declare const NavigationMenuPositioner: React_2.ForwardRefExoticComponent<Omit<NavigationMenuPositionerProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace NavigationMenuPositioner {
+    type State = NavigationMenuPositionerState;
+    type Props = NavigationMenuPositionerProps;
+}
+
+declare interface NavigationMenuPositionerProps extends UseAnchorPositioningSharedParameters, BaseUIComponentProps<'div', NavigationMenuPositionerState> {}
+
+declare interface NavigationMenuPositionerState {
+    /**
+     * Whether the navigation 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 CSS transitions should be disabled.
+     */
+    instant: boolean;
+}
+
+/**
+ * Groups all parts of the navigation menu.
+ * Renders a `<nav>` element at the root, or `<div>` element when nested.
+ *
+ * Documentation: [Base UI Navigation Menu](https://base-ui.com/react/components/navigation-menu)
+ */
+declare const NavigationMenuRoot: {
+    <Value = any>(props: NavigationMenuRoot.Props<Value>): React_2.JSX.Element;
+};
+
+declare namespace NavigationMenuRoot {
+    type State = NavigationMenuRootState;
+    type Props<TValue = any> = NavigationMenuRootProps<TValue>;
+    type Value<TValue = any> = TValue | null;
+    type Actions = NavigationMenuRootActions;
+    type ChangeEventReason = NavigationMenuRootChangeEventReason;
+    type ChangeEventDetails = NavigationMenuRootChangeEventDetails;
+}
+
+declare interface NavigationMenuRootActions {
+    unmount: () => void;
+}
+
+declare type NavigationMenuRootChangeEventDetails = BaseUIChangeEventDetails<NavigationMenuRoot.ChangeEventReason>;
+
+declare type NavigationMenuRootChangeEventReason = typeof REASONS.triggerPress | typeof REASONS.triggerHover | typeof REASONS.outsidePress | typeof REASONS.listNavigation | typeof REASONS.focusOut | typeof REASONS.escapeKey | typeof REASONS.linkPress | typeof REASONS.none;
+
+declare interface NavigationMenuRootProps<Value = any> extends BaseUIComponentProps<'nav', NavigationMenuRootState> {
+    /**
+     * A ref to imperative actions.
+     */
+    actionsRef?: React_2.RefObject<NavigationMenuRoot.Actions | null> | undefined;
+    /**
+     * Event handler called after any animations complete when the navigation menu is closed.
+     */
+    onOpenChangeComplete?: ((open: boolean) => void) | undefined;
+    /**
+     * The controlled value of the navigation menu item that should be currently open.
+     * When non-nullish, the menu will be open. When nullish, the menu will be closed.
+     *
+     * To render an uncontrolled navigation menu, use the `defaultValue` prop instead.
+     * @default null
+     */
+    value?: Value | null | undefined;
+    /**
+     * The uncontrolled value of the item that should be initially selected.
+     *
+     * To render a controlled navigation menu, use the `value` prop instead.
+     * @default null
+     */
+    defaultValue?: Value | null | undefined;
+    /**
+     * Callback fired when the value changes.
+     */
+    onValueChange?: ((value: Value | null, eventDetails: NavigationMenuRoot.ChangeEventDetails) => void) | undefined;
+    /**
+     * How long to wait before opening the navigation popup. Specified in milliseconds.
+     * @default 50
+     */
+    delay?: number | undefined;
+    /**
+     * How long to wait before closing the navigation popup. Specified in milliseconds.
+     * @default 50
+     */
+    closeDelay?: number | undefined;
+    /**
+     * The orientation of the navigation menu.
+     * @default 'horizontal'
+     */
+    orientation?: 'horizontal' | 'vertical' | undefined;
+}
+
+declare interface NavigationMenuRootState {
+    /**
+     * If `true`, the popup is open.
+     */
+    open: boolean;
+    /**
+     * Whether the navigation menu is nested.
+     */
+    nested: boolean;
+}
+
+/**
+ * Opens the navigation menu popup when hovered or clicked, revealing the
+ * associated content.
+ * Renders a `<button>` element.
+ *
+ * Documentation: [Base UI Navigation Menu](https://base-ui.com/react/components/navigation-menu)
+ */
+declare const NavigationMenuTrigger: React_2.ForwardRefExoticComponent<Omit<NavigationMenuTriggerProps, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+
+declare namespace NavigationMenuTrigger {
+    type State = NavigationMenuTriggerState;
+    type Props = NavigationMenuTriggerProps;
+}
+
+declare interface NavigationMenuTriggerProps extends NativeButtonProps, BaseUIComponentProps<'button', NavigationMenuTriggerState> {}
+
+declare interface NavigationMenuTriggerState {
+    /**
+     * If `true`, the popup is open and the item is active.
+     */
+    open: boolean;
+}
+
+/**
+ * The clipping viewport of the navigation menu's current content.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Navigation Menu](https://base-ui.com/react/components/navigation-menu)
+ */
+declare const NavigationMenuViewport: React_2.ForwardRefExoticComponent<Omit<NavigationMenuViewportProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare namespace NavigationMenuViewport {
+    type State = NavigationMenuViewportState;
+    type Props = NavigationMenuViewportProps;
+}
+
+declare interface NavigationMenuViewportProps extends BaseUIComponentProps<'div', NavigationMenuViewportState> {}
+
+declare interface NavigationMenuViewportState {}
+
+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 const pointer: "pointer";
+
+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 function Root<Value = any>({ className, dir, separator, 'aria-label': ariaLabel, ...props }: WithStringClassName<NavigationMenu.Root.Props<Value>> & {
     separator?: React_2.ReactNode;
 }): JSX_2.Element;
 
+declare const scrub: "scrub";
+
+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 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]> };
+
+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;
 };