@bazza-ui/react 0.0.0-snapshot-20260205122957

package/dist/data-surface-Dyb-d-72.d.cts

@@ -0,0 +1,2136 @@
+import * as React from 'react';
+import { J as CheckedChangeEventDetails, K as RadioValueChangeEventDetails, r as ListboxStore, P as PopupMenuOpenChangeReason, V as VirtualItem, H as HighlightChangeEventDetails, U as UseListboxItemParams, y as UseListboxItemReturn, F as FilterFn } from './use-listbox-item-bi01_uzf.cjs';
+import { PopoverArrowProps, Popover, PopoverBackdropProps, PopoverPopupProps, PopoverPortalProps, PopoverPositionerProps, PopoverRootProps } from '@base-ui/react/popover';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/**
+ * Render function that receives props and state, returns a React element.
+ */
+type ComponentRenderFn<Props, State> = (props: Props, state: State) => React.ReactElement<unknown>;
+/**
+ * HTML props with ref support.
+ */
+type HTMLProps<T = any> = React.HTMLAttributes<T> & {
+    ref?: React.Ref<T> | undefined;
+};
+/**
+ * Props shared by all Bazza UI components.
+ * Includes className (string or state-based function), render prop, and style (object or state-based function).
+ */
+type ComponentProps<ElementType extends React.ElementType, State, RenderFunctionProps = HTMLProps> = Omit<React.ComponentPropsWithRef<ElementType>, 'className' | 'color' | 'defaultValue' | 'defaultChecked'> & {
+    /**
+     * 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);
+    /**
+     * 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?: ComponentRenderFn<RenderFunctionProps, State> | React.ReactElement;
+    /**
+     * Style applied to the element, or a function that
+     * returns a style object based on the component's state.
+     */
+    style?: React.CSSProperties | ((state: State) => React.CSSProperties | undefined);
+};
+
+interface PopupMenuCheckboxItemState extends Record<string, unknown> {
+    /**
+     * Whether the item is highlighted (via keyboard or pointer).
+     */
+    highlighted: boolean;
+    /**
+     * Whether the item is disabled.
+     */
+    disabled: boolean;
+    /**
+     * Whether the item is currently checked.
+     */
+    checked: boolean;
+}
+interface PopupMenuCheckboxItemProps extends ComponentProps<'div', PopupMenuCheckboxItem.State> {
+    /**
+     * The controlled checked state.
+     */
+    checked?: boolean;
+    /**
+     * The default checked state for uncontrolled mode.
+     * @default false
+     */
+    defaultChecked?: boolean;
+    /**
+     * Callback fired when the checked state changes.
+     * The second parameter contains event details including the reason for the change.
+     */
+    onCheckedChange?: (checked: boolean, eventDetails: CheckedChangeEventDetails) => void;
+    /**
+     * Additional keywords to match against when filtering.
+     * Useful for aliases or synonyms.
+     */
+    keywords?: string[];
+    /**
+     * Whether this item is disabled.
+     * Disabled items are not selectable and are skipped during keyboard navigation.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Callback when this item is selected (via click or Enter key).
+     */
+    onSelect?: () => void;
+    /**
+     * Whether to force render this item regardless of filter results.
+     * @default false
+     */
+    forceMount?: boolean;
+    /**
+     * Whether clicking this item should close the menu.
+     * @default false
+     */
+    closeOnClick?: boolean;
+    /**
+     * Keyboard shortcut to trigger this item.
+     * When the menu is focused and the user presses this key, the item will be selected.
+     * Should be a single character (e.g., "1", "a", etc.).
+     */
+    shortcut?: string;
+}
+/**
+ * A selectable checkbox item within a popup menu.
+ * Manages its own checked state independently.
+ * Renders a `<div>` element with role="menuitemcheckbox".
+ */
+declare const PopupMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<PopupMenuCheckboxItem.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuCheckboxItem {
+    type State = PopupMenuCheckboxItemState;
+    interface Props extends PopupMenuCheckboxItemProps {
+    }
+}
+
+interface PopupMenuItemState extends Record<string, unknown> {
+    /**
+     * Whether the item is highlighted (via keyboard or pointer).
+     */
+    highlighted: boolean;
+    /**
+     * Whether the item is disabled.
+     */
+    disabled: boolean;
+}
+interface PopupMenuItemProps extends ComponentProps<'div', PopupMenuItem.State> {
+    /**
+     * Unique value for this item used for filtering.
+     * If not provided, will be inferred from textContent.
+     */
+    value?: string;
+    /**
+     * Additional keywords to match against when filtering.
+     * Useful for aliases or synonyms.
+     */
+    keywords?: string[];
+    /**
+     * Whether this item is disabled.
+     * Disabled items are not selectable and are skipped during keyboard navigation.
+     */
+    disabled?: boolean;
+    /**
+     * Callback when this item is selected (via click or Enter key).
+     */
+    onSelect?: () => void;
+    /**
+     * Whether to force render this item regardless of filter results.
+     * @default false
+     */
+    forceMount?: boolean;
+    /**
+     * Whether clicking this item should close the menu.
+     * @default true
+     */
+    closeOnClick?: boolean;
+    /**
+     * Keyboard shortcut to trigger this item.
+     * When the menu is focused and the user presses this key, the item will be selected.
+     * Should be a single character (e.g., "1", "a", etc.).
+     */
+    shortcut?: string;
+}
+/**
+ * A selectable item in the popup menu.
+ * Renders a `<div>` element with role="option".
+ */
+declare const PopupMenuItem: React.ForwardRefExoticComponent<Omit<PopupMenuItem.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuItem {
+    type State = PopupMenuItemState;
+    interface Props extends PopupMenuItemProps {
+    }
+}
+
+interface PopupMenuRadioGroupState extends Record<string, unknown> {
+    /**
+     * Whether the radio group is disabled.
+     */
+    disabled: boolean;
+}
+interface PopupMenuRadioGroupProps extends ComponentProps<'div', PopupMenuRadioGroup.State> {
+    /**
+     * The controlled selected value.
+     */
+    value?: string;
+    /**
+     * The default value for uncontrolled mode.
+     */
+    defaultValue?: string;
+    /**
+     * Callback fired when the selected value changes.
+     * The second parameter contains event details including the reason for the change.
+     */
+    onValueChange?: (value: string, eventDetails: RadioValueChangeEventDetails) => void;
+    /**
+     * Whether all items in this group are disabled.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Whether to force render this group regardless of filter results.
+     * @default false
+     */
+    forceMount?: boolean;
+    children: React.ReactNode;
+}
+/**
+ * Groups radio items together and manages the selected value.
+ * Only one item can be selected at a time within a radio group.
+ * Renders a `<div>` element with role="group".
+ */
+declare const PopupMenuRadioGroup: React.ForwardRefExoticComponent<Omit<PopupMenuRadioGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuRadioGroup {
+    type State = PopupMenuRadioGroupState;
+    interface Props extends PopupMenuRadioGroupProps {
+    }
+}
+
+interface PopupMenuRadioItemState extends Record<string, unknown> {
+    /**
+     * Whether the item is highlighted (via keyboard or pointer).
+     */
+    highlighted: boolean;
+    /**
+     * Whether the item is disabled.
+     */
+    disabled: boolean;
+    /**
+     * Whether the item is currently selected/checked.
+     */
+    checked: boolean;
+}
+interface PopupMenuRadioItemProps extends ComponentProps<'div', PopupMenuRadioItem.State> {
+    /**
+     * The value to set when this item is selected.
+     * This is required and must be unique within the RadioGroup.
+     */
+    value: string;
+    /**
+     * Additional keywords to match against when filtering.
+     * Useful for aliases or synonyms.
+     */
+    keywords?: string[];
+    /**
+     * Whether this item is disabled.
+     * Disabled items are not selectable and are skipped during keyboard navigation.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Callback when this item is selected.
+     */
+    onSelect?: () => void;
+    /**
+     * Whether to force render this item regardless of filter results.
+     * @default false
+     */
+    forceMount?: boolean;
+    /**
+     * Whether clicking this item should close the menu.
+     * @default false
+     */
+    closeOnClick?: boolean;
+    /**
+     * Keyboard shortcut to trigger this item.
+     * When the menu is focused and the user presses this key, the item will be selected.
+     * Should be a single character (e.g., "1", "a", etc.).
+     */
+    shortcut?: string;
+}
+/**
+ * A selectable radio item within a RadioGroup.
+ * Only one RadioItem can be selected at a time within a RadioGroup.
+ * Renders a `<div>` element with role="menuitemradio".
+ */
+declare const PopupMenuRadioItem: React.ForwardRefExoticComponent<Omit<PopupMenuRadioItemProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuRadioItem {
+    type State = PopupMenuRadioItemState;
+    interface Props extends PopupMenuRadioItemProps {
+    }
+}
+
+interface PopupMenuSubmenuTriggerState extends Record<string, unknown> {
+    /**
+     * Whether this is a submenu trigger (always true).
+     */
+    submenuTrigger: boolean;
+    /**
+     * Whether the submenu popup is open.
+     */
+    popupOpen: boolean;
+    /**
+     * Whether the submenu owns keyboard focus.
+     */
+    popupFocused: boolean;
+    /**
+     * Whether the item is highlighted.
+     */
+    highlighted: boolean;
+    /**
+     * Whether the item is disabled.
+     */
+    disabled: boolean;
+}
+interface PopupMenuSubmenuTriggerProps extends ComponentProps<'div', PopupMenuSubmenuTrigger.State> {
+    /**
+     * Explicit unique identifier for this item in the store.
+     * When provided (e.g., from data-first API's computed composite ID),
+     * this takes priority over `value` for store registration.
+     */
+    id?: string;
+    /**
+     * Unique value for this item used for filtering.
+     * If not provided, will be inferred from textContent.
+     */
+    value?: string;
+    /**
+     * Additional keywords to match against when filtering.
+     * Useful for aliases or synonyms.
+     */
+    keywords?: string[];
+    /**
+     * Whether this item is disabled.
+     * Disabled items are not selectable and are skipped during keyboard navigation.
+     */
+    disabled?: boolean;
+    /**
+     * Whether to force render this item regardless of filter results.
+     * @default false
+     */
+    forceMount?: boolean;
+    /**
+     * Whether the submenu opens when this trigger is highlighted.
+     * @default true
+     */
+    openOnHighlight?: boolean;
+    /**
+     * Delay before opening the submenu (in milliseconds).
+     * Can be a number (applies to both pointer and keyboard) or an object
+     * with separate `pointer` and `keyboard` values.
+     * @default { pointer: 0, keyboard: 150 }
+     */
+    delay?: number | {
+        pointer?: number;
+        keyboard?: number;
+    };
+    /**
+     * Delay before closing the submenu when pointer leaves (in milliseconds).
+     * @default 0
+     */
+    closeDelay?: number;
+}
+/**
+ * A menu item that opens a submenu when hovered.
+ * Must be used within PopupMenu.Submenu.
+ * Renders a `<div>` element with role="menuitem" wrapped in Popover.Trigger.
+ */
+declare const PopupMenuSubmenuTrigger: React.ForwardRefExoticComponent<Omit<PopupMenuSubmenuTrigger.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuSubmenuTrigger {
+    type State = PopupMenuSubmenuTriggerState;
+    interface Props extends PopupMenuSubmenuTriggerProps {
+    }
+}
+
+/**
+ * Library-agnostic result from an async loader.
+ * Compatible with TanStack Query, SWR, and custom loaders.
+ */
+interface AsyncLoaderResult<T> {
+    /** The loaded data, undefined while loading or on error */
+    data: T | undefined;
+    /** Error if the load failed, null otherwise */
+    error: Error | null;
+    /** Whether the loader is currently loading */
+    isLoading: boolean;
+    /** Whether the loader encountered an error */
+    isError: boolean;
+    /** Optional function to refetch the data */
+    refetch?: () => void;
+}
+/**
+ * Props passed to loader components.
+ * The component should call hooks internally and pass the result to children.
+ */
+interface LoaderComponentProps {
+    /** Search query (for query-dependent loaders) */
+    query: string;
+    /** Render function receiving loader state */
+    children: (state: AsyncLoaderResult<NodeDef[]>) => React.ReactNode;
+}
+/**
+ * Static loader configuration.
+ * Loads data once, then filters client-side.
+ */
+interface StaticLoaderConfig {
+    type: 'static';
+    /**
+     * Component that calls hooks and provides loader state.
+     * This component pattern allows hooks to be called legally within React's rules.
+     */
+    Loader: React.ComponentType<LoaderComponentProps>;
+    /**
+     * When to trigger the loader:
+     * - 'eager': Load when menu opens (good for deep search)
+     * - 'lazy': Load when submenu opens (default)
+     * @default 'lazy'
+     */
+    loadStrategy?: 'eager' | 'lazy';
+}
+/**
+ * Query-dependent loader configuration.
+ * Refetches based on search query - server does the filtering.
+ */
+interface QueryDependentLoaderConfig {
+    type: 'query';
+    /**
+     * Component that calls hooks and provides loader state.
+     * Receives the current search query as a prop.
+     */
+    Loader: React.ComponentType<LoaderComponentProps>;
+    /**
+     * Minimum query length before fetching.
+     * @default 1
+     */
+    minQueryLength?: number;
+    /**
+     * Initial query to use when the loader becomes active.
+     * Set to '' to fetch all items immediately when the submenu opens.
+     * If undefined, waits for user to type before fetching.
+     */
+    initialQuery?: string;
+    /**
+     * When to trigger the loader:
+     * - 'eager': Load when root menu opens (good for deep search)
+     * - 'lazy': Load when submenu opens (default)
+     * @default 'lazy'
+     */
+    loadStrategy?: 'eager' | 'lazy';
+    /**
+     * What to show when query is below minQueryLength.
+     * - 'empty': Show nothing
+     * - 'placeholder': Show placeholderNodes
+     * @default 'empty'
+     */
+    belowMinBehavior?: 'empty' | 'placeholder';
+    /**
+     * Placeholder nodes shown when query is below minQueryLength.
+     */
+    placeholderNodes?: NodeDef[];
+}
+/**
+ * Union of all async loader configurations.
+ */
+type AsyncLoaderConfig = StaticLoaderConfig | QueryDependentLoaderConfig;
+/**
+ * Base options for async nodes that apply to both loader types.
+ */
+interface AsyncNodesBaseOptions {
+    /**
+     * Include this menu's async content in parent's deep search.
+     * - Static loaders: default true (data loaded, filter client-side)
+     * - Query loaders: default true (pass query to server)
+     */
+    includeInDeepSearch?: boolean;
+}
+/**
+ * Static async nodes configuration for submenus.
+ */
+type StaticAsyncNodesConfig = StaticLoaderConfig & AsyncNodesBaseOptions;
+/**
+ * Query-dependent async nodes configuration for submenus.
+ */
+type QueryAsyncNodesConfig = QueryDependentLoaderConfig & AsyncNodesBaseOptions;
+/**
+ * Async nodes configuration for submenus.
+ * Union of static and query-dependent loader configs with deep search options.
+ */
+type AsyncNodesConfig = StaticAsyncNodesConfig | QueryAsyncNodesConfig;
+/**
+ * Async state exposed to submenu render functions.
+ */
+interface AsyncRenderState {
+    /** Whether the loader is currently loading */
+    isLoading: boolean;
+    /** Whether the loader encountered an error */
+    isError: boolean;
+    /** The error if any */
+    error: Error | null;
+    /** For query loaders: whether query is below minQueryLength */
+    isBelowMinLength?: boolean;
+}
+/**
+ * Aggregate async state exposed to DataList children.
+ */
+interface AsyncState {
+    /** Any loader is currently loading */
+    isLoading: boolean;
+    /** Static loaders specifically are loading */
+    isStaticLoading: boolean;
+    /** Query loaders specifically are loading */
+    isQueryLoading: boolean;
+    /** Menus that failed (skipped from results) */
+    skippedMenus: Array<{
+        id: string;
+        reason: 'error';
+    }>;
+}
+/**
+ * Submenu node info passed in breadcrumbs context.
+ * Contains the full submenu definition for maximum flexibility.
+ */
+interface BreadcrumbNode {
+    /** The submenu node definition */
+    node: SubmenuDef;
+    /** The submenu's value */
+    value: string;
+    /** The submenu's explicit id (if provided) */
+    id?: string;
+}
+/**
+ * Context passed to the getQualifiedRowId function.
+ * Provides all information needed to generate a unique ID for a row.
+ */
+interface GetQualifiedRowIdContext {
+    /** The node definition */
+    node: ItemDef | RadioItemDef | CheckboxItemDef | SubmenuDef;
+    /** The node's value (node.value) - used for search/filtering and as fallback identifier */
+    value: string;
+    /** The node's explicit id (node.id) - if provided, treated as globally unique */
+    id: string | undefined;
+    /** Position in the flattened display list (0-based) */
+    index: number;
+    /**
+     * Breadcrumb nodes from root to parent.
+     * Contains full submenu node definitions for maximum flexibility.
+     */
+    breadcrumbs: BreadcrumbNode[];
+    /** Whether deep search is currently active (search query meets minLength threshold) */
+    isDeepSearching: boolean;
+    /** Search context, null if browsing */
+    search: {
+        query: string;
+        score: number;
+    } | null;
+    /** Whether surfaced via deep search (rendered outside its home menu) */
+    isDeepSearchResult: boolean;
+    /** Group context, if any */
+    group: {
+        id: string;
+        label?: string;
+    } | null;
+    /** Radio group context, if any */
+    radioGroup: {
+        id: string;
+        label?: string;
+    } | null;
+}
+/**
+ * Function that generates a unique qualified ID for a row.
+ * Used for React keys, store registration, and DOM id attributes.
+ *
+ * Default behavior:
+ * - If node.id is provided, use it as-is (treat as globally unique)
+ * - Otherwise, compute from breadcrumbs + value when deep searching
+ *
+ * @example
+ * ```ts
+ * // Custom implementation
+ * const getQualifiedRowId: GetQualifiedRowIdFn = (ctx) => {
+ *   // Use explicit id if provided
+ *   if (ctx.id) return ctx.id
+ *
+ *   // Otherwise, build from breadcrumbs + value
+ *   const path = ctx.breadcrumbs.map(b => b.id ?? slugify(b.value))
+ *   return [...path, slugify(ctx.value)].join('.')
+ * }
+ * ```
+ */
+type GetQualifiedRowIdFn = (context: GetQualifiedRowIdContext) => string;
+/**
+ * Context passed to item and submenu render functions.
+ * Provides information about the current rendering context (search, breadcrumbs, state).
+ */
+interface RowRenderContext {
+    /**
+     * Search context - the query in the menu where this row is being rendered.
+     * `null` if no active search (browsing mode).
+     */
+    search: {
+        /** Current search query */
+        query: string;
+        /** Match score for this row (0-1, higher = better match) */
+        score: number;
+    } | null;
+    /**
+     * Full path of submenu nodes from root to this row's parent.
+     * Contains the full submenu node definitions for maximum flexibility.
+     * Empty array [] for items directly in root menu.
+     */
+    breadcrumbs: BreadcrumbNode[];
+    /**
+     * True if this row is being rendered outside its "home" menu
+     * (surfaced via deep search from an ancestor menu).
+     */
+    isDeepSearchResult: boolean;
+    /** Whether this row is currently highlighted/focused */
+    highlighted: boolean;
+    /** Whether this row is disabled */
+    disabled: boolean;
+    /**
+     * The group this item belongs to, if any.
+     * `null` if the item is not inside a group.
+     */
+    group: {
+        id: string;
+        label?: string;
+    } | null;
+}
+/**
+ * Props to spread onto the Item component.
+ * Derived from PopupMenuItemProps.
+ */
+type ItemRenderProps = {
+    /**
+     * Qualified unique ID for the item.
+     * Must be passed to the rendered component for navigation to work.
+     * This is the computed qualified ID (includes breadcrumb path for deep search results).
+     */
+    id: string;
+    /**
+     * The original value from the node definition.
+     * Use this for display, search matching, or any logic that needs the raw value.
+     */
+    value: string;
+} & Required<Pick<PopupMenuItemProps, 'disabled'>> & Pick<PopupMenuItemProps, 'closeOnClick' | 'onSelect' | 'shortcut'>;
+/**
+ * Parameters passed to item render functions.
+ */
+interface ItemRenderParams {
+    /** Props to spread onto the Item component */
+    props: ItemRenderProps;
+    /** Context for conditional rendering (includes props values for convenience) */
+    context: RowRenderContext & {
+        /** The node's value (ItemDef.value) */
+        value: string;
+        disabled: boolean;
+    };
+}
+/**
+ * Props to spread onto the RadioItem component.
+ * Derived from PopupMenuRadioItemProps.
+ */
+type RadioItemRenderProps = {
+    /**
+     * Qualified unique ID for the radio item.
+     * Must be passed to the rendered component for navigation to work.
+     */
+    id: string;
+} & Required<Pick<PopupMenuRadioItemProps, 'value' | 'disabled'>> & Pick<PopupMenuRadioItemProps, 'closeOnClick' | 'onSelect' | 'shortcut'>;
+/**
+ * Parameters passed to radio item render functions.
+ */
+interface RadioItemRenderParams {
+    /** Props to spread onto the RadioItem component */
+    props: RadioItemRenderProps;
+    /** Context for conditional rendering (includes props values for convenience) */
+    context: RowRenderContext & {
+        /** The node's value (RadioItemDef.value) */
+        value: string;
+        disabled: boolean;
+    };
+}
+/**
+ * Props to spread onto the SubmenuTrigger component.
+ * Derived from PopupMenuSubmenuTriggerProps.
+ */
+type SubmenuRenderProps = {
+    /**
+     * Qualified unique ID for the submenu trigger.
+     * Must be passed to the rendered component for navigation to work.
+     */
+    id: string;
+    /**
+     * The original value from the node definition.
+     */
+    value: string;
+} & Required<Pick<PopupMenuSubmenuTriggerProps, 'disabled'>>;
+/**
+ * Parameters passed to submenu render functions.
+ * Includes context plus the submenu's child nodes and render function.
+ */
+interface SubmenuRenderParams {
+    /** Props to spread onto the SubmenuTrigger */
+    props: SubmenuRenderProps;
+    /** Context for conditional rendering (includes props values for convenience) */
+    context: RowRenderContext & {
+        /** The node's value (SubmenuDef.value) */
+        value: string;
+        disabled: boolean;
+        /** Async loading state (if asyncNodes configured) */
+        async?: AsyncRenderState;
+    };
+    /**
+     * The submenu's static child node definitions.
+     * Does NOT include async results - use `asyncContent` for that.
+     */
+    nodes: NodeDef[];
+    /**
+     * Async content configuration for this submenu.
+     * Pass this to the submenu's DataSurface to enable async loading
+     * with the submenu's own search query (independent of parent search).
+     */
+    asyncContent?: AsyncNodesConfig;
+    /**
+     * Function to render a child node.
+     * Call this for each node in the submenu's list.
+     */
+    renderNode: (node: NodeDef) => React.ReactNode;
+}
+/**
+ * Context passed to group render functions.
+ * Contains information about the group's state during search.
+ */
+interface GroupRenderContext {
+    /**
+     * Search context with the best match score among items in this group.
+     * `null` if no active search (browsing mode).
+     */
+    search: {
+        /** Current search query */
+        query: string;
+        /** Best match score among items in this group (0-1) */
+        bestScore: number;
+    } | null;
+    /** Number of matching items in this group */
+    matchCount: number;
+    /**
+     * Breadcrumb nodes if this group is from a surfaced submenu.
+     * Empty array [] for groups in the root menu.
+     */
+    breadcrumbs: BreadcrumbNode[];
+    /** Whether this group is from deep search (surfaced from a submenu) */
+    isDeepSearchResult: boolean;
+}
+/**
+ * Parameters passed to group render functions.
+ */
+interface GroupRenderParams {
+    /** Props (empty for groups, but consistent structure) */
+    props: Record<string, never>;
+    /** Context for conditional rendering (includes label for convenience) */
+    context: GroupRenderContext & {
+        /** The group's label */
+        label?: string;
+    };
+    /** Pre-rendered matching children */
+    children: React.ReactNode;
+}
+/**
+ * Props to spread onto the CheckboxItem component.
+ * Derived from PopupMenuCheckboxItemProps.
+ */
+type CheckboxItemRenderProps = {
+    /**
+     * Qualified unique ID for the checkbox item.
+     * Must be passed to the rendered component for navigation to work.
+     */
+    id: string;
+    /**
+     * The original value from the node definition.
+     */
+    value: string;
+} & Required<Pick<PopupMenuCheckboxItemProps, 'disabled'>> & Pick<PopupMenuCheckboxItemProps, 'checked' | 'onCheckedChange' | 'closeOnClick'>;
+/**
+ * Parameters passed to checkbox item render functions.
+ */
+interface CheckboxItemRenderParams {
+    /** Props to spread onto the CheckboxItem component */
+    props: CheckboxItemRenderProps;
+    /** Context for conditional rendering (includes props values for convenience) */
+    context: RowRenderContext & {
+        /** The node's value (CheckboxItemDef.value) */
+        value: string;
+        checked?: boolean;
+        disabled: boolean;
+    };
+}
+/**
+ * Props to spread onto the RadioGroup component.
+ * Derived from PopupMenuRadioGroupProps.
+ */
+type RadioGroupRenderProps = Required<Pick<PopupMenuRadioGroupProps, 'disabled'>> & Pick<PopupMenuRadioGroupProps, 'value' | 'onValueChange'>;
+/**
+ * Parameters passed to radio group render functions.
+ */
+interface RadioGroupRenderParams {
+    /** Props to spread onto the RadioGroup component */
+    props: RadioGroupRenderProps;
+    /** Context for conditional rendering */
+    context: GroupRenderContext & {
+        /** The radio group's label */
+        label?: string;
+        /** Current selected value */
+        value?: string;
+        /** Whether the radio group is disabled */
+        disabled: boolean;
+    };
+    /** Pre-rendered radio items */
+    children: React.ReactNode;
+}
+/**
+ * Base properties shared by all node types.
+ */
+interface BaseNodeDef {
+    /**
+     * Unique identifier for this node.
+     * If not provided, a composite ID is generated from the `value` and breadcrumbs
+     * using the `getItemId` function.
+     */
+    id?: string;
+    /** Whether this node is hidden */
+    hidden?: boolean;
+}
+/**
+ * Item node definition.
+ * Represents a selectable menu item.
+ * Props derived from PopupMenuItemProps.
+ */
+interface ItemDef extends BaseNodeDef, Required<Pick<PopupMenuItemProps, 'value'>>, Pick<PopupMenuItemProps, 'keywords' | 'disabled' | 'onSelect' | 'closeOnClick' | 'shortcut'> {
+    kind: 'item';
+    /**
+     * Render function for this item row.
+     * Returns the JSX for the item.
+     */
+    render: (params: ItemRenderParams) => React.ReactNode;
+}
+/**
+ * Radio item node definition.
+ * Represents a selectable radio menu item for use within RadioGroupDef.
+ * Props derived from PopupMenuRadioItemProps.
+ */
+interface RadioItemDef extends BaseNodeDef, Required<Pick<PopupMenuRadioItemProps, 'value'>>, Pick<PopupMenuRadioItemProps, 'keywords' | 'disabled' | 'onSelect' | 'closeOnClick' | 'shortcut'> {
+    kind: 'radio-item';
+    /**
+     * Render function for this radio item row.
+     * Returns the JSX for the radio item.
+     */
+    render: (params: RadioItemRenderParams) => React.ReactNode;
+}
+/**
+ * Checkbox item node definition.
+ * Represents a toggleable checkbox menu item.
+ * Props derived from PopupMenuCheckboxItemProps.
+ */
+interface CheckboxItemDef extends BaseNodeDef, Pick<PopupMenuCheckboxItemProps, 'keywords' | 'disabled' | 'checked' | 'onCheckedChange' | 'closeOnClick'> {
+    kind: 'checkbox-item';
+    /**
+     * Primary identifier and search text for this checkbox item.
+     * Used for search matching and as the default identifier.
+     */
+    value: string;
+    /**
+     * Render function for this checkbox item row.
+     * Returns the JSX for the checkbox item.
+     */
+    render: (params: CheckboxItemRenderParams) => React.ReactNode;
+}
+/**
+ * Submenu node definition.
+ * Represents a submenu trigger that opens a nested menu.
+ * Props derived from PopupMenuSubmenuTriggerProps.
+ */
+interface SubmenuDef extends BaseNodeDef, Required<Pick<PopupMenuSubmenuTriggerProps, 'value'>>, Pick<PopupMenuSubmenuTriggerProps, 'keywords' | 'disabled'> {
+    kind: 'submenu';
+    /** Static child nodes */
+    nodes?: NodeDef[];
+    /**
+     * Async child nodes configuration.
+     * When provided, the Loader component will be rendered to fetch async data.
+     * Async nodes are merged with static nodes.
+     */
+    asyncNodes?: AsyncNodesConfig;
+    /**
+     * Whether to include this submenu's children in deep search.
+     * @default true
+     */
+    deepSearch?: boolean;
+    /**
+     * Render function for the entire submenu structure.
+     * Should return the complete submenu: trigger, portal, positioner, popup, surface, list.
+     */
+    render: (params: SubmenuRenderParams) => React.ReactNode;
+}
+/**
+ * Render params for separator nodes.
+ */
+interface SeparatorRenderParams {
+    /** Props to spread on the separator element */
+    props: {
+        /** Unique identifier */
+        id?: string;
+    };
+}
+/**
+ * Separator node definition.
+ * Represents a visual separator between items.
+ */
+interface SeparatorDef {
+    kind: 'separator';
+    /** Optional identifier */
+    id?: string;
+    /** Optional render function for custom separator rendering */
+    render?: (params: SeparatorRenderParams) => React.ReactNode;
+}
+/**
+ * Group node definition.
+ * Represents a group of items with an optional label.
+ */
+interface GroupDef {
+    kind: 'group';
+    /** Unique identifier for this group */
+    id: string;
+    /** Optional group heading/label */
+    label?: string;
+    /** Child nodes in this group */
+    nodes: NodeDef[];
+    /** Optional render function for the group container */
+    render?: (params: GroupRenderParams) => React.ReactNode;
+}
+/**
+ * Radio group node definition.
+ * Represents a group of radio items where only one can be selected.
+ * Props derived from PopupMenuRadioGroupProps.
+ */
+interface RadioGroupDef extends Pick<PopupMenuRadioGroupProps, 'value' | 'onValueChange' | 'disabled'> {
+    kind: 'radio-group';
+    /** Unique identifier for this radio group */
+    id: string;
+    /** Optional group heading/label */
+    label?: string;
+    /** Whether the radio group is hidden */
+    hidden?: boolean;
+    /** Child nodes in this radio group - must be RadioItemDef nodes */
+    nodes: RadioItemDef[];
+    /** Optional render function for the radio group container */
+    render?: (params: RadioGroupRenderParams) => React.ReactNode;
+}
+/**
+ * Helper function to create a radio group definition with proper typing.
+ */
+declare function defineRadioGroup(def: RadioGroupDef): RadioGroupDef;
+/**
+ * Union of all node definition types.
+ */
+type NodeDef = ItemDef | RadioItemDef | CheckboxItemDef | SubmenuDef | SeparatorDef | GroupDef | RadioGroupDef;
+/**
+ * A node with its search score and breadcrumb path.
+ * Used internally during filtering and scoring.
+ */
+interface ScoredNode {
+    /** The original node definition */
+    node: ItemDef | RadioItemDef | CheckboxItemDef | SubmenuDef;
+    /** Search match score (0-1) */
+    score: number;
+    /**
+     * Breadcrumb nodes leading to this node.
+     * Contains the full submenu definitions for maximum flexibility.
+     */
+    breadcrumbs: BreadcrumbNode[];
+    /** The group this node belongs to, if any */
+    group: {
+        id: string;
+        label?: string;
+        groupDef: GroupDef;
+    } | null;
+    /** The radio group this node belongs to, if any */
+    radioGroup: {
+        id: string;
+        label?: string;
+        radioGroupDef: RadioGroupDef;
+    } | null;
+}
+/**
+ * A row node ready for display with its render context.
+ * Used for items, radio items, checkbox items, and submenu triggers.
+ */
+interface DisplayRowNode {
+    /** The original node definition */
+    node: ItemDef | RadioItemDef | CheckboxItemDef | SubmenuDef;
+    /** Pre-computed render context for this node */
+    context: RowRenderContext;
+    /** Radio group this node belongs to, if rendering inside one */
+    radioGroup?: {
+        id: string;
+        label?: string;
+    };
+    /**
+     * Computed composite ID for this node.
+     * Includes breadcrumb path for deep search results (e.g., "status.in-progress").
+     * Set after filtering via `computeItemIds`.
+     */
+    compositeId?: string;
+}
+/**
+ * A group node ready for display with its render context.
+ * Contains the group definition and its matching items.
+ */
+interface DisplayGroupNode {
+    kind: 'group';
+    /** The group definition */
+    group: GroupDef;
+    /** Pre-computed render context for this group */
+    context: GroupRenderContext;
+    /** Display nodes for items within this group */
+    items: DisplayRowNode[];
+    /** Best match score among items in this group */
+    bestScore: number;
+}
+/**
+ * A radio group node ready for display with its render context.
+ * Contains the radio group definition and its items.
+ */
+interface DisplayRadioGroupNode {
+    kind: 'radio-group';
+    /** The radio group definition */
+    radioGroup: RadioGroupDef;
+    /** Pre-computed render context for this radio group */
+    context: GroupRenderContext;
+    /** Display nodes for items within this radio group */
+    items: DisplayRowNode[];
+    /** Best match score among items in this radio group */
+    bestScore: number;
+}
+/**
+ * A separator node ready for display.
+ */
+interface DisplaySeparatorNode {
+    kind: 'separator';
+    /** The separator definition */
+    separator: SeparatorDef;
+}
+/**
+ * Union of all display node types.
+ * Can be a row node (item/submenu), group node, radio group node, or separator.
+ */
+type DisplayNode = DisplayRowNode | DisplayGroupNode | DisplayRadioGroupNode | DisplaySeparatorNode;
+/**
+ * Type guard for DisplayGroupNode.
+ */
+declare function isDisplayGroupNode(node: DisplayNode): node is DisplayGroupNode;
+/**
+ * Type guard for DisplayRadioGroupNode.
+ */
+declare function isDisplayRadioGroupNode(node: DisplayNode): node is DisplayRadioGroupNode;
+/**
+ * Type guard for DisplaySeparatorNode.
+ */
+declare function isDisplaySeparatorNode(node: DisplayNode): node is DisplaySeparatorNode;
+/**
+ * Type guard for DisplayRowNode (items, checkbox items, submenus).
+ */
+declare function isDisplayRowNode(node: DisplayNode): node is DisplayRowNode;
+/**
+ * Defines how groups behave during deep search.
+ * - 'flatten': Groups become invisible, items shown in flat list by score.
+ * - 'preserve': Groups are shown as containers with their matching items.
+ * Note: Radio groups are ALWAYS preserved regardless of this setting.
+ */
+type GroupBehavior = 'flatten' | 'preserve';
+/**
+ * Defines how radio groups behave during deep search.
+ * - 'flatten': Radio group items are shown individually in the flat list (not recommended).
+ * - 'preserve': Radio group is shown with only matching items visible.
+ * - 'preserve-show-all': Radio group is shown with ALL items visible when any item matches.
+ *   This is useful when you want users to see all options in a radio group.
+ */
+type RadioGroupBehavior = 'flatten' | 'preserve' | 'preserve-show-all';
+/**
+ * Configuration for deep search behavior.
+ */
+interface DeepSearchConfig {
+    /** Whether deep search is enabled */
+    enabled?: boolean;
+    /** Minimum query length before deep search activates */
+    minLength?: number;
+    /**
+     * How groups behave during search results.
+     * Only affects search mode - groups are always shown in browse mode.
+     * Note: Radio groups have their own behavior controlled by radioGroupSearchBehavior.
+     * @default 'preserve'
+     */
+    groupSearchBehavior?: GroupBehavior;
+    /**
+     * How radio groups behave during search results.
+     * - 'flatten': Radio items shown individually (not recommended).
+     * - 'preserve': Only matching radio items are shown (default).
+     * - 'preserve-show-all': All radio items are shown when any item matches.
+     * @default 'preserve'
+     */
+    radioGroupSearchBehavior?: RadioGroupBehavior;
+    /**
+     * Whether to sort groups by their best-matching item's score.
+     * Only applies when groupSearchBehavior: 'preserve'.
+     * @default true
+     */
+    sortGroups?: boolean;
+}
+/**
+ * Props for the DataSurface component.
+ */
+interface DataSurfaceProps {
+    /** The menu content (node definitions with render functions) */
+    content?: NodeDef[];
+    /**
+     * Async content configuration for root-level async loading.
+     * When provided, the Loader component will be rendered to fetch async data.
+     * Async content is merged with static content.
+     */
+    asyncContent?: AsyncLoaderConfig;
+    /** Deep search configuration */
+    deepSearch?: DeepSearchConfig | boolean;
+    /** Filter function or false to disable filtering */
+    filter?: ((value: string, search: string, keywords?: string[]) => number) | false;
+    /** Controlled search value */
+    search?: string;
+    /** Callback when search value changes */
+    onSearchChange?: (search: string) => void;
+    /** Default search value for uncontrolled usage */
+    defaultSearch?: string;
+    /** Whether navigation should loop */
+    loop?: boolean;
+    /** Auto-highlight behavior when menu opens */
+    autoHighlightFirst?: boolean | string;
+    /**
+     * Whether to clear search on close.
+     * - `true`: clear immediately when menu closes (default)
+     * - `false`: preserve search when menu closes
+     * - `'after-exit'`: clear after exit animation completes
+     */
+    clearSearchOnClose?: boolean | 'after-exit';
+    /**
+     * Function to generate qualified IDs for row items.
+     * Called for each item when rendering to produce IDs for:
+     * - React keys
+     * - Store registration
+     * - DOM id attributes
+     *
+     * @default Uses node.id if provided, otherwise qualifies with breadcrumbs + slugified value
+     */
+    getQualifiedRowId?: GetQualifiedRowIdFn;
+    /** Children (Input, List, etc.) */
+    children: React.ReactNode;
+}
+/**
+ * State passed to the DataList render function.
+ */
+interface DataListChildrenState {
+    /** Current search query (empty string if browsing) */
+    search: string;
+    /**
+     * Display nodes (filtered and scored if searching).
+     * Can include groups (DisplayGroupNode) or radio groups (DisplayRadioGroupNode)
+     * when groupSearchBehavior: 'preserve'.
+     */
+    nodes: DisplayNode[];
+    /**
+     * Function to render a node.
+     * Handles items, submenus, groups, and radio groups, calling their render functions with context.
+     */
+    renderNode: (displayNode: DisplayNode) => React.ReactNode;
+    /** Number of visible items (counting items inside groups) */
+    count: number;
+    /** Whether deep search is active (query length >= minLength) */
+    isDeepSearching: boolean;
+    /** Aggregate async loading state across all menus */
+    async: AsyncState;
+}
+/**
+ * Props for the DataList component.
+ */
+interface DataListProps {
+    /**
+     * Render function for the list content.
+     * Receives the current state and returns JSX.
+     */
+    children: (state: DataListChildrenState) => React.ReactNode;
+    /** Accessible label for the listbox */
+    label?: string;
+    /** Additional class name */
+    className?: string;
+    /** Additional styles */
+    style?: React.CSSProperties;
+    /**
+     * When true, measures row widths and applies `--row-width` CSS variable.
+     * Keeps the list at the maximum width seen while scrolling.
+     * Useful for virtualized lists where content width varies.
+     * @default true
+     */
+    measureRowWidth?: boolean;
+    /**
+     * Maximum width cap for row measurement (in pixels).
+     * Only used when `measureRowWidth` is true.
+     */
+    maxRowWidth?: number;
+}
+
+/**
+ * Virtual anchor for positioning the menu at a specific point.
+ * Used by ContextMenu to position at cursor location.
+ */
+interface VirtualAnchor {
+    getBoundingClientRect(): DOMRect;
+}
+/**
+ * Virtualization configuration passed from Root/Submenu to Surface.
+ */
+interface VirtualizationConfig {
+    /** Whether virtualization mode is enabled */
+    virtualized: boolean;
+    /** Pre-registered items for virtualization */
+    items: VirtualItem[];
+    /**
+     * Callback when highlighted item changes (for scroll sync).
+     * The third parameter contains event details including the reason for the change.
+     */
+    onHighlightChange?: (id: string | null, index: number, eventDetails: HighlightChangeEventDetails) => void;
+}
+/**
+ * Shared context value for popup menus.
+ * Both DropdownMenu.Root and ContextMenu.Root provide this context.
+ */
+interface PopupMenuContextValue {
+    /** The Listbox store instance */
+    store: ListboxStore;
+    /** Nesting depth: 0 = root menu, 1+ = submenu */
+    depth: number;
+    /** Close the entire menu tree (deepest submenu to root, sequentially) */
+    closeAll: (reason?: PopupMenuOpenChangeReason, event?: Event) => void;
+    /** Register a surface (submenu) for closeAll tracking. Returns unregister function. */
+    registerSurface: (depth: number, setOpen: (open: boolean) => void) => () => void;
+    /** Virtualization configuration (if enabled) */
+    virtualization?: VirtualizationConfig;
+    /**
+     * Virtual anchor for positioning.
+     * Used by ContextMenu to position at cursor location.
+     * DropdownMenu uses the Popover's anchor (trigger button) instead.
+     */
+    virtualAnchor?: VirtualAnchor;
+    /**
+     * Type of menu for positioning logic.
+     * - 'dropdown': positions relative to trigger button
+     * - 'context': positions at cursor with fixed positioning
+     */
+    menuType: 'dropdown' | 'context';
+    /**
+     * When to close the menu on outside interactions.
+     * - 'pointerdown': Close immediately when pointer is pressed outside (default)
+     * - 'click': Close when a full click (pointerdown + pointerup) occurs outside
+     * @default 'pointerdown'
+     */
+    closeOnOutsidePress: 'click' | 'pointerdown';
+    /**
+     * Function to generate qualified unique IDs for rows.
+     * Defined once at the root level and applied to all surfaces (root and submenus).
+     * If not provided, uses the default implementation.
+     */
+    getQualifiedRowId?: GetQualifiedRowIdFn;
+}
+declare const PopupMenuContext: React.Context<PopupMenuContextValue | null>;
+/**
+ * Hook to access the popup menu context.
+ * Throws if used outside a popup menu.
+ */
+declare function usePopupMenuContext(): PopupMenuContextValue;
+/**
+ * Hook to optionally access the popup menu context.
+ * Returns null if used outside a popup menu.
+ */
+declare function useMaybePopupMenuContext(): PopupMenuContextValue | null;
+
+interface SubmenuContextValue {
+    /** Whether the submenu is open */
+    open: boolean;
+    /** Set the submenu open state */
+    setOpen: (open: boolean) => void;
+    /** Reference to the trigger element */
+    triggerRef: React.RefObject<HTMLElement | null>;
+    /** Reference to the submenu content element (for aim guard rect calculations) */
+    contentRef: React.RefObject<HTMLElement | null>;
+    /** Surface ID of the parent menu (for keyboard navigation back) */
+    parentSurfaceId: string;
+    /** Surface ID of this submenu (for keyboard navigation into) */
+    childSurfaceId: string;
+    /**
+     * Whether pressing Escape in this submenu closes the entire menu from the root.
+     * When true, Escape closes the entire menu tree.
+     * When false, Escape only closes this submenu and moves focus to the parent.
+     * @default true
+     */
+    closeRootOnEsc: boolean;
+}
+declare const SubmenuContext: React.Context<SubmenuContextValue | null>;
+declare function useSubmenuContext(): SubmenuContextValue;
+declare function useMaybeSubmenuContext(): SubmenuContextValue | null;
+
+interface PopupMenuArrowProps extends PopoverArrowProps {
+}
+/**
+ * An optional arrow element to render alongside the popup menu.
+ * This can be used to help visually link the trigger with the popup.
+ * Must be rendered inside `Popup`.
+ * Renders a `<div>` element.
+ */
+declare const PopupMenuArrow: React.ForwardRefExoticComponent<PopupMenuArrowProps & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuArrow {
+    type Props = PopupMenuArrowProps;
+    type State = Popover.Arrow.State;
+}
+
+interface PopupMenuBackdropProps extends PopoverBackdropProps {
+    /**
+     * Controls when the backdrop becomes visible for submenus.
+     * - `"focus"`: Show when the submenu becomes the focus owner (prevents flicker on hover).
+     *   If a deeper submenu is open, the backdrop remains visible.
+     * - `"open"`: Show as soon as the submenu opens, regardless of focus.
+     *
+     * @default "focus" for submenus, "open" for root menu
+     */
+    showOn?: 'focus' | 'open';
+}
+/**
+ * An overlay displayed beneath the popup menu.
+ *
+ * For submenus with `showOn="focus"` (default), the backdrop visibility follows these rules:
+ * - If this submenu is at the end of the open chain (deepest), it must be
+ *   the focus owner to show the backdrop (prevents flicker on hover)
+ * - If this submenu is in the chain but not at the end (has a deeper submenu open),
+ *   the backdrop remains visible
+ *
+ * With `showOn="open"`, the backdrop shows as soon as the submenu opens.
+ *
+ * Renders a `<div>` element with `pointer-events: none`.
+ */
+declare const PopupMenuBackdrop: React.ForwardRefExoticComponent<PopupMenuBackdropProps & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuBackdrop {
+    type Props = PopupMenuBackdropProps;
+    type State = Popover.Backdrop.State;
+}
+
+interface PopupMenuPopupState extends Popover.Popup.State {
+    /**
+     * Whether this popup is a submenu (not the root menu).
+     */
+    isSubmenu: boolean;
+}
+interface PopupMenuPopupProps extends Omit<PopoverPopupProps, 'className'> {
+    /**
+     * CSS class applied to the element, or a function that
+     * returns a class based on the component's state.
+     */
+    className?: string | ((state: PopupMenuPopupState) => string);
+}
+/**
+ * A container for the popup menu contents.
+ * Wraps Popover.Popup with:
+ * - Aim guard clearing when pointer enters submenu
+ * - Focus ownership transfer when pointer enters submenu
+ * - Auto-focus disabled for submenus (focus managed by FocusOwner system)
+ *
+ * Renders a `<div>` element.
+ */
+declare const PopupMenuPopup: React.ForwardRefExoticComponent<PopupMenuPopupProps & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuPopup {
+    type Props = PopupMenuPopupProps;
+    type State = PopupMenuPopupState;
+}
+
+interface PopupMenuPortalProps extends PopoverPortalProps {
+}
+/**
+ * A portal element that moves the popup to a different part of the DOM.
+ * By default, the portal element is appended to `<body>`.
+ */
+declare const PopupMenuPortal: React.ForwardRefExoticComponent<PopoverPortalProps & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuPortal {
+    type Props = PopoverPortalProps;
+    type State = Popover.Portal.State;
+}
+
+declare enum PopupMenuPositionerCssVars {
+    /**
+     * The available width between the trigger and the edge of the viewport.
+     * @type {number}
+     */
+    availableWidth = "--available-width",
+    /**
+     * The available height between the trigger and the edge of the viewport.
+     * @type {number}
+     */
+    availableHeight = "--available-height",
+    /**
+     * The anchor's width.
+     * @type {number}
+     */
+    anchorWidth = "--anchor-width",
+    /**
+     * The anchor's height.
+     * @type {number}
+     */
+    anchorHeight = "--anchor-height",
+    /**
+     * The coordinates that this element is anchored to. Used for animations and transitions.
+     * @type {string}
+     */
+    transformOrigin = "--transform-origin",
+    /**
+     * The width of the positioner element.
+     * @type {number}
+     */
+    positionerWidth = "--positioner-width",
+    /**
+     * The height of the positioner element.
+     * @type {number}
+     */
+    positionerHeight = "--positioner-height"
+}
+
+/**
+ * Extended align options for popup menus.
+ * - 'start' | 'center' | 'end': Standard Base UI alignment
+ * - 'list-start': Align trigger top with the top of the List component (horizontal sides only)
+ */
+type PopupMenuPositionerAlign = PopoverPositionerProps['align'] | 'list-start';
+interface PopupMenuPositionerProps extends Omit<PopoverPositionerProps, 'align' | 'style'> {
+    /**
+     * Override the virtual anchor from context.
+     * Useful for nested menus that need different positioning.
+     */
+    virtualAnchor?: {
+        getBoundingClientRect(): DOMRect;
+    };
+    /**
+     * How to align the popup relative to the specified side.
+     * - 'start': align to start of anchor
+     * - 'center': align to center of anchor
+     * - 'end': align to end of anchor
+     * - 'list-start': align the List component's top with the anchor top (horizontal sides only)
+     * @default 'start' for submenus, 'center' for root dropdowns
+     */
+    align?: PopupMenuPositionerAlign;
+    /**
+     * Custom styles for the positioner.
+     * Note: During list-start alignment measurement, `transition: 'none'` is
+     * temporarily applied to prevent visual flash.
+     */
+    style?: React.CSSProperties;
+}
+/**
+ * Positions the popup menu against its anchor.
+ * Wraps Popover.Positioner with:
+ * - Automatic virtualAnchor from PopupMenuContext (for context menus)
+ * - Smart default positioning based on depth and menu type
+ * - Smart collision avoidance: shift for horizontal menus, flip for vertical
+ * - 'list-start' alignment for horizontal submenus
+ *
+ * Renders a `<div>` element.
+ */
+declare const PopupMenuPositioner: React.ForwardRefExoticComponent<PopupMenuPositionerProps & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuPositioner {
+    type Props = PopupMenuPositionerProps;
+    type State = Popover.Positioner.State;
+}
+
+interface UsePopupMenuItemParams extends Omit<UseListboxItemParams, 'aimGuard' | 'onAfterSelect'> {
+    /**
+     * Whether clicking this item should close the menu.
+     * @default true
+     */
+    closeOnClick?: boolean;
+}
+type UsePopupMenuItemReturn = UseListboxItemReturn;
+/**
+ * Hook that provides all shared logic for navigatable/highlightable popup menu items.
+ * This is a thin wrapper around useListboxItem that automatically adds aim-guard
+ * support and handles close-on-click behavior.
+ *
+ * @see useListboxItem for full documentation
+ */
+declare function usePopupMenuItem(params: UsePopupMenuItemParams): UsePopupMenuItemReturn;
+
+interface PopupMenuIconState extends Record<string, unknown> {
+    /**
+     * Whether the popup is currently open.
+     */
+    open: boolean;
+}
+interface PopupMenuIconProps extends ComponentProps<'span', PopupMenuIcon.State> {
+}
+/**
+ * An icon that indicates the trigger opens a popup.
+ * Typically used inside the trigger to show a chevron or dropdown arrow.
+ * Renders a `<span>` element.
+ */
+declare const PopupMenuIcon: React.ForwardRefExoticComponent<Omit<PopupMenuIcon.Props, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare namespace PopupMenuIcon {
+    type State = PopupMenuIconState;
+    interface Props extends PopupMenuIconProps {
+    }
+}
+
+interface PopupMenuEmptyState extends Record<string, unknown> {
+}
+interface PopupMenuEmptyProps extends ComponentProps<'div', PopupMenuEmpty.State> {
+    children: React.ReactNode;
+}
+/**
+ * Renders when no items match the current search query.
+ * Only visible when there's an active search with zero results.
+ * Renders a `<div>` element.
+ */
+declare const PopupMenuEmpty: React.ForwardRefExoticComponent<Omit<PopupMenuEmpty.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuEmpty {
+    type State = PopupMenuEmptyState;
+    interface Props extends PopupMenuEmptyProps {
+    }
+}
+
+interface PopupMenuInputState extends Record<string, unknown> {
+    /**
+     * Whether the input is active (visible).
+     * Only relevant when `hideUntilActive` is true.
+     */
+    active: boolean;
+}
+interface PopupMenuInputProps extends Omit<ComponentProps<'input', PopupMenuInput.State>, 'value' | 'onChange' | 'type'> {
+    /**
+     * Controlled value for the search input.
+     * If provided, this takes precedence over the Surface's search state.
+     */
+    value?: string;
+    /**
+     * Callback when the input value changes.
+     */
+    onValueChange?: (value: string) => void;
+    /**
+     * When true, the input is not rendered until the user starts typing.
+     * The List receives focus initially, and typing a character activates the input.
+     * Once activated, the input stays visible until the menu closes.
+     * @default false
+     */
+    hideUntilActive?: boolean;
+}
+/**
+ * Search input for filtering popup menu items.
+ * Handles keyboard navigation (Arrow keys, Ctrl+N/P, Enter).
+ * Renders an `<input>` element.
+ */
+declare const PopupMenuInput: React.ForwardRefExoticComponent<Omit<PopupMenuInput.Props, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare namespace PopupMenuInput {
+    type State = PopupMenuInputState;
+    interface Props extends PopupMenuInputProps {
+    }
+}
+
+/**
+ * CSS custom properties applied to the List component.
+ */
+declare enum PopupMenuListCssVars {
+    /**
+     * The maximum measured row width.
+     * Applied when `measureRowWidth` is true.
+     * Useful for keeping virtualized lists at a consistent width.
+     * @type {number}
+     */
+    rowWidth = "--row-width"
+}
+
+/**
+ * State passed to children render function.
+ */
+interface PopupMenuListChildrenState {
+    /** Current search query */
+    search: string;
+    /** Number of items matching the current filter */
+    filteredCount: number;
+}
+interface PopupMenuListState extends Record<string, unknown> {
+}
+interface PopupMenuListProps extends Omit<ComponentProps<'div', PopupMenuList.State>, 'children'> {
+    /**
+     * Content to render inside the list.
+     * Can be a render function that receives the current search state.
+     */
+    children: React.ReactNode | ((state: PopupMenuListChildrenState) => React.ReactNode);
+    /**
+     * Accessible label for the listbox.
+     * @default 'Suggestions'
+     */
+    label?: string;
+    /**
+     * When true, measures row widths and applies `--row-width` CSS variable.
+     * Keeps the list at the maximum width seen while scrolling.
+     * Useful for virtualized lists where content width varies.
+     * @default true
+     */
+    measureRowWidth?: boolean;
+    /**
+     * Maximum width cap for row measurement (in pixels).
+     * Only used when `measureRowWidth` is true.
+     */
+    maxRowWidth?: number;
+}
+/**
+ * Container for popup menu items.
+ * Supports render props for accessing search state.
+ * Renders a `<div>` element with role="listbox".
+ */
+declare const PopupMenuList: React.ForwardRefExoticComponent<Omit<PopupMenuList.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuList {
+    type State = PopupMenuListState;
+    type ChildrenState = PopupMenuListChildrenState;
+    interface Props extends PopupMenuListProps {
+    }
+}
+
+type Direction = 'up' | 'down';
+interface PopupMenuScrollArrowState extends Record<string, unknown> {
+    /**
+     * The scroll direction this arrow controls.
+     */
+    direction: Direction;
+    /**
+     * Whether there is content to scroll in this direction.
+     */
+    visible: boolean;
+}
+interface PopupMenuScrollArrowProps extends ComponentProps<'div', PopupMenuScrollArrow.State> {
+    /**
+     * The direction to scroll when hovering over this arrow.
+     */
+    direction: Direction;
+    /**
+     * Whether to keep the element mounted when there's nothing to scroll.
+     * When false (default), the element is not rendered.
+     * When true, the element is rendered but can be styled via `data-visible="false"`.
+     * @default false
+     */
+    keepMounted?: boolean;
+    /**
+     * Scroll speed in pixels per frame.
+     * @default 10
+     */
+    scrollSpeed?: number;
+}
+/**
+ * Base scroll arrow component used by ScrollUpArrow and ScrollDownArrow.
+ * Shows when there is content to scroll in the specified direction.
+ * Scrolls the list continuously while pointer is over it.
+ * Renders a `<div>` element.
+ */
+declare const PopupMenuScrollArrow: React.ForwardRefExoticComponent<Omit<PopupMenuScrollArrow.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuScrollArrow {
+    type State = PopupMenuScrollArrowState;
+    interface Props extends PopupMenuScrollArrowProps {
+    }
+}
+interface PopupMenuScrollUpArrowProps extends Omit<PopupMenuScrollArrowProps, 'direction'> {
+}
+/**
+ * A scroll indicator that appears when there's content above.
+ * Scrolls the list up continuously while pointer is over it.
+ * Renders a `<div>` element.
+ */
+declare const PopupMenuScrollUpArrow: React.ForwardRefExoticComponent<Omit<PopupMenuScrollUpArrow.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuScrollUpArrow {
+    type State = PopupMenuScrollArrowState;
+    interface Props extends PopupMenuScrollUpArrowProps {
+    }
+}
+interface PopupMenuScrollDownArrowProps extends Omit<PopupMenuScrollArrowProps, 'direction'> {
+}
+/**
+ * A scroll indicator that appears when there's content below.
+ * Scrolls the list down continuously while pointer is over it.
+ * Renders a `<div>` element.
+ */
+declare const PopupMenuScrollDownArrow: React.ForwardRefExoticComponent<Omit<PopupMenuScrollDownArrow.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuScrollDownArrow {
+    type State = PopupMenuScrollArrowState;
+    interface Props extends PopupMenuScrollDownArrowProps {
+    }
+}
+
+interface PopupMenuSurfaceState extends Record<string, unknown> {
+}
+interface PopupMenuSurfaceProps extends ComponentProps<'div', PopupMenuSurface.State> {
+    /**
+     * Filter function for matching items against search query.
+     * Returns a score between 0 and 1 (0 = no match, > 0 = match).
+     * Pass `false` to disable filtering entirely.
+     * @default commandScore (fuzzy matching)
+     */
+    filter?: FilterFn | false;
+    /**
+     * Controlled search value.
+     */
+    search?: string;
+    /**
+     * Callback when search value changes.
+     */
+    onSearchChange?: (search: string) => void;
+    /**
+     * Default search value for uncontrolled usage.
+     * @default ''
+     */
+    defaultSearch?: string;
+    /**
+     * Whether navigation should loop from last to first item and vice versa.
+     * @default true
+     */
+    loop?: boolean;
+    /**
+     * Controls auto-highlighting behavior when the menu opens.
+     * - `true`: highlight the first item (default)
+     * - `false`: don't auto-highlight any item
+     * - `string`: highlight the item with this specific value
+     * @default true
+     */
+    autoHighlightFirst?: boolean | string;
+    /**
+     * Whether to clear the search query when the menu closes.
+     * - `true`: clear immediately when menu closes (default)
+     * - `false`: preserve search when menu closes
+     * - `'after-exit'`: clear after exit animation completes
+     * @default true
+     */
+    clearSearchOnClose?: boolean | 'after-exit';
+    /**
+     * Whether to skip auto-focusing the input/list when this surface becomes the focus owner.
+     * Useful for Combobox where the input is outside the popup and should retain focus.
+     * @default false
+     */
+    skipAutoFocus?: boolean;
+    /**
+     * Ordered list of item values when using `filter={false}`.
+     * This tells the store the intended display order for navigation/highlighting.
+     * Required when `filter={false}` - must always be provided with the current visible items.
+     */
+    orderedItems?: string[];
+    children: React.ReactNode;
+}
+/**
+ * Provides search context and manages item registration for popup menu.
+ * Place inside PopupMenu.Popup to enable search functionality.
+ * Renders a `<div>` element.
+ */
+declare const PopupMenuSurface: React.ForwardRefExoticComponent<Omit<PopupMenuSurface.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuSurface {
+    type State = PopupMenuSurfaceState;
+    interface Props extends PopupMenuSurfaceProps {
+    }
+}
+
+interface PopupMenuCheckboxItemIndicatorState extends Record<string, unknown> {
+    /**
+     * Whether the parent checkbox item is currently checked.
+     */
+    checked: boolean;
+    /**
+     * Whether the parent checkbox item is currently highlighted.
+     */
+    highlighted: boolean;
+    /**
+     * Whether the parent checkbox item is disabled.
+     */
+    disabled: boolean;
+    /**
+     * Toggle the checked state without triggering closeOnClick.
+     * Useful when you want clicking directly on the indicator to toggle
+     * without closing the menu.
+     */
+    toggle: () => void;
+}
+interface PopupMenuCheckboxItemIndicatorProps extends ComponentProps<'span', PopupMenuCheckboxItemIndicator.State> {
+    /**
+     * Whether to keep the indicator mounted in the DOM when unchecked.
+     * Useful for animations.
+     * @default false
+     */
+    keepMounted?: boolean;
+}
+/**
+ * A visual indicator that shows when a CheckboxItem is checked.
+ * Must be used within a CheckboxItem component.
+ * Renders a `<span>` element with aria-hidden="true".
+ */
+declare const PopupMenuCheckboxItemIndicator: React.ForwardRefExoticComponent<Omit<PopupMenuCheckboxItemIndicator.Props, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare namespace PopupMenuCheckboxItemIndicator {
+    type State = PopupMenuCheckboxItemIndicatorState;
+    interface Props extends PopupMenuCheckboxItemIndicatorProps {
+    }
+}
+
+interface PopupMenuRadioGroupValueProps {
+    /**
+     * The controlled selected value.
+     */
+    value: string | undefined;
+    /**
+     * Callback fired when the selected value changes.
+     * The second parameter contains event details including the reason for the change.
+     */
+    onValueChange?: (value: string, eventDetails: RadioValueChangeEventDetails) => void;
+    /**
+     * Whether all items in this group are disabled.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Children to render within the radio group context.
+     */
+    children: React.ReactNode;
+}
+/**
+ * Headless provider for radio group state.
+ * Use this to wrap DataSurface when using RadioItems in deep search.
+ * Does not render any DOM element - only provides context.
+ *
+ * @example
+ * ```tsx
+ * const [theme, setTheme] = useState('light')
+ *
+ * <DropdownMenu.RadioGroupValue value={theme} onValueChange={setTheme}>
+ *   <DropdownMenu.DataSurface content={content}>
+ *     ...
+ *   </DropdownMenu.DataSurface>
+ * </DropdownMenu.RadioGroupValue>
+ * ```
+ */
+declare function PopupMenuRadioGroupValue(props: PopupMenuRadioGroupValueProps): react_jsx_runtime.JSX.Element;
+declare namespace PopupMenuRadioGroupValue {
+    interface Props extends PopupMenuRadioGroupValueProps {
+    }
+}
+
+interface PopupMenuRadioItemIndicatorState extends Record<string, unknown> {
+    /**
+     * Whether the parent radio item is currently selected/checked.
+     */
+    checked: boolean;
+    /**
+     * Whether the parent radio item is currently highlighted.
+     */
+    highlighted: boolean;
+    /**
+     * Whether the parent radio item is disabled.
+     */
+    disabled: boolean;
+}
+interface PopupMenuRadioItemIndicatorProps extends ComponentProps<'span', PopupMenuRadioItemIndicator.State> {
+    /**
+     * Whether to keep the indicator mounted in the DOM when unchecked.
+     * Useful for animations.
+     * @default false
+     */
+    keepMounted?: boolean;
+}
+/**
+ * A visual indicator that shows when a RadioItem is selected.
+ * Must be used within a RadioItem component.
+ * Renders a `<span>` element with aria-hidden="true".
+ */
+declare const PopupMenuRadioItemIndicator: React.ForwardRefExoticComponent<Omit<PopupMenuRadioItemIndicator.Props, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare namespace PopupMenuRadioItemIndicator {
+    type State = PopupMenuRadioItemIndicatorState;
+    interface Props extends PopupMenuRadioItemIndicatorProps {
+    }
+}
+
+interface PopupMenuGroupState extends Record<string, unknown> {
+    /**
+     * Whether the group is hidden due to no matching items.
+     */
+    hidden: boolean;
+}
+interface PopupMenuGroupProps extends ComponentProps<'div', PopupMenuGroup.State> {
+    /**
+     * Whether to force render this group regardless of filter results.
+     * @default false
+     */
+    forceMount?: boolean;
+    children: React.ReactNode;
+}
+/**
+ * Groups related popup menu items together.
+ * Hidden when no child items match the current filter.
+ * Renders a `<div>` element with role="group".
+ */
+declare const PopupMenuGroup: React.ForwardRefExoticComponent<Omit<PopupMenuGroup.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuGroup {
+    type State = PopupMenuGroupState;
+    interface Props extends PopupMenuGroupProps {
+    }
+}
+
+interface PopupMenuGroupLabelState extends Record<string, unknown> {
+}
+interface PopupMenuGroupLabelProps extends ComponentProps<'div', PopupMenuGroupLabel.State> {
+    children: React.ReactNode;
+}
+/**
+ * A label/heading for a group of popup menu items.
+ * Renders a `<div>` element with role="presentation".
+ */
+declare const PopupMenuGroupLabel: React.ForwardRefExoticComponent<Omit<PopupMenuGroupLabel.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuGroupLabel {
+    type State = PopupMenuGroupLabelState;
+    interface Props extends PopupMenuGroupLabelProps {
+    }
+}
+
+interface PopupMenuSeparatorState extends Record<string, unknown> {
+}
+interface PopupMenuSeparatorProps extends ComponentProps<'div', PopupMenuSeparator.State> {
+    /**
+     * Whether to always render the separator, even during search.
+     * By default, separators are hidden when there's an active search query.
+     * @default false
+     */
+    alwaysRender?: boolean;
+}
+/**
+ * A visual separator between popup menu items.
+ * Hidden during active search unless `alwaysRender` is true.
+ * Renders a `<div>` element with role="separator".
+ */
+declare const PopupMenuSeparator: React.ForwardRefExoticComponent<Omit<PopupMenuSeparator.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuSeparator {
+    type State = PopupMenuSeparatorState;
+    interface Props extends PopupMenuSeparatorProps {
+    }
+}
+
+/**
+ * State for the Shortcut component, passed to children render function.
+ */
+interface PopupMenuShortcutState extends Record<string, unknown> {
+    /**
+     * The keyboard shortcut value from the parent Item.
+     */
+    shortcut: string | undefined;
+    /**
+     * Whether the parent item is highlighted.
+     */
+    highlighted: boolean;
+}
+interface PopupMenuShortcutProps extends Omit<ComponentProps<'kbd', PopupMenuShortcut.State>, 'children'> {
+    /**
+     * Content to render inside the shortcut.
+     * Can be a render function that receives the shortcut value.
+     * If not provided, renders the shortcut value from the parent Item.
+     */
+    children?: React.ReactNode | ((state: PopupMenuShortcutState) => React.ReactNode);
+}
+/**
+ * Displays the keyboard shortcut for a menu item.
+ * Must be used within a PopupMenu.Item component.
+ * Renders a `<kbd>` element by default.
+ *
+ * @example
+ * ```tsx
+ * // Auto-renders the shortcut value
+ * <PopupMenu.Item shortcut="1">
+ *   Icebox
+ *   <PopupMenu.Shortcut />
+ * </PopupMenu.Item>
+ *
+ * // Custom rendering with children as function
+ * <PopupMenu.Item shortcut="1">
+ *   Icebox
+ *   <PopupMenu.Shortcut>
+ *     {({ shortcut }) => <span className="key">{shortcut}</span>}
+ *   </PopupMenu.Shortcut>
+ * </PopupMenu.Item>
+ * ```
+ */
+declare const PopupMenuShortcut: React.ForwardRefExoticComponent<Omit<PopupMenuShortcut.Props, "ref"> & React.RefAttributes<HTMLElement>>;
+declare namespace PopupMenuShortcut {
+    type State = PopupMenuShortcutState;
+    interface Props extends PopupMenuShortcutProps {
+    }
+}
+
+interface PopupMenuSubmenuRootProps extends Omit<PopoverRootProps, 'open' | 'onOpenChange' | 'defaultOpen'> {
+    /**
+     * Whether the submenu is open.
+     * Use for controlled mode.
+     */
+    open?: boolean;
+    /**
+     * Callback when the open state changes.
+     * The second parameter contains event details including the reason for the change.
+     */
+    onOpenChange?: (open: boolean, eventDetails: Popover.Root.ChangeEventDetails) => void;
+    /**
+     * Whether the submenu is initially open.
+     * Use for uncontrolled mode.
+     * @default false
+     */
+    defaultOpen?: boolean;
+    /**
+     * Whether pressing Escape in this submenu closes the entire menu from the root.
+     * When true (default), Escape closes the entire menu tree.
+     * When false, Escape only closes this submenu and moves focus to the parent.
+     * @default true
+     */
+    closeRootOnEsc?: boolean;
+    /**
+     * Whether virtualization mode is enabled for this submenu.
+     * When true, items should provide an explicit `index` prop and
+     * the `items` prop should be provided for navigation to work correctly.
+     * @default false
+     */
+    virtualized?: boolean;
+    /**
+     * Pre-registered items for virtualization.
+     * When provided with `virtualized={true}`, this allows navigation to work
+     * for items that aren't currently mounted in the DOM.
+     */
+    items?: VirtualItem[];
+    /**
+     * Callback when the highlighted item changes.
+     * Useful for synchronizing with a virtualizer (e.g., scrollToIndex).
+     * Only called when `virtualized={true}`.
+     */
+    onHighlightChange?: (id: string | null, index: number) => void;
+    /**
+     * Event handler called after any open/close animations have completed.
+     * When `clearSearchOnClose="after-exit"` is set on Surface, the search
+     * will be cleared before this callback is invoked.
+     */
+    onOpenChangeComplete?: (open: boolean) => void;
+    children: React.ReactNode;
+}
+/**
+ * Groups all parts of a submenu.
+ * Manages open state and provides context to children.
+ * Creates its own ListboxStore independent from the parent menu.
+ * Doesn't render its own HTML element.
+ */
+declare function PopupMenuSubmenuRoot(props: PopupMenuSubmenuRootProps): react_jsx_runtime.JSX.Element;
+declare namespace PopupMenuSubmenuRoot {
+    interface Props extends PopupMenuSubmenuRootProps {
+    }
+    type ChangeEventDetails = Popover.Root.ChangeEventDetails;
+    type Actions = Popover.Root.Actions;
+}
+
+interface PopupMenuSubmenuTriggerIndicatorState extends Record<string, unknown> {
+    /**
+     * Whether the submenu popup is open.
+     */
+    popupOpen: boolean;
+    /**
+     * Whether the submenu owns keyboard focus.
+     */
+    popupFocused: boolean;
+}
+interface PopupMenuSubmenuTriggerIndicatorProps extends ComponentProps<'span', PopupMenuSubmenuTriggerIndicator.State> {
+}
+/**
+ * An indicator element for submenu triggers that reflects the submenu's open and focus state.
+ * Typically used to render a chevron or arrow icon.
+ * Must be used within PopupMenu.SubmenuTrigger.
+ * Renders a `<span>` element.
+ */
+declare const PopupMenuSubmenuTriggerIndicator: React.ForwardRefExoticComponent<Omit<PopupMenuSubmenuTriggerIndicator.Props, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare namespace PopupMenuSubmenuTriggerIndicator {
+    type State = PopupMenuSubmenuTriggerIndicatorState;
+    interface Props extends PopupMenuSubmenuTriggerIndicatorProps {
+    }
+}
+
+interface DataSurfaceContextValue {
+    /** The original node definitions */
+    content: NodeDef[];
+    /** Async content configuration for root-level async loading */
+    asyncContent?: AsyncLoaderConfig;
+    /** Deep search configuration */
+    deepSearchConfig: DeepSearchConfig;
+    /** List element ID for aria-activedescendant */
+    listId: string;
+    /** Function to generate qualified IDs for row items */
+    getQualifiedRowId: GetQualifiedRowIdFn;
+}
+declare const DataSurfaceContext: React.Context<DataSurfaceContextValue | null>;
+declare function useDataSurfaceContext(): DataSurfaceContextValue;
+declare function useMaybeDataSurfaceContext(): DataSurfaceContextValue | null;
+type RenderNodeFn = (displayNode: DisplayNode) => React.ReactNode;
+
+interface PopupMenuDataListProps extends DataListProps {
+    /** Render function for custom element */
+    render?: React.ReactElement;
+}
+/**
+ * DataList renders the menu items using a render prop pattern.
+ * It reads from the store for search and computes filtered nodes.
+ *
+ * Place inside PopupMenuDataSurface.
+ * Wraps PopupMenuList for keyboard navigation and accessibility.
+ */
+declare const PopupMenuDataList: React.ForwardRefExoticComponent<PopupMenuDataList.Props & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuDataList {
+    interface Props extends PopupMenuDataListProps {
+    }
+    type ChildrenState = DataListChildrenState;
+}
+
+interface PopupMenuDataSurfaceProps extends DataSurfaceProps {
+    /** Custom class name */
+    className?: string;
+    /** Custom styles */
+    style?: React.CSSProperties;
+    /** Render function for custom element */
+    render?: React.ReactElement;
+}
+/**
+ * DataSurface provides deep search functionality for popup menus.
+ * It wraps the standard Surface and adds data-first search capabilities.
+ *
+ * Place inside PopupMenu.Popup to enable deep search functionality.
+ * Renders a `<div>` element.
+ */
+declare const PopupMenuDataSurface: React.ForwardRefExoticComponent<PopupMenuDataSurface.Props & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuDataSurface {
+    interface Props extends PopupMenuDataSurfaceProps {
+    }
+}
+
+export { type PopupMenuScrollArrowState as $, type AsyncLoaderResult as A, PopupMenuSubmenuTrigger as B, type ComponentProps as C, PopupMenuSubmenuTriggerIndicator as D, type PopupMenuPopupState as E, type PopupMenuArrowProps as F, type GetQualifiedRowIdFn as G, type PopupMenuBackdropProps as H, type PopupMenuEmptyProps as I, type PopupMenuEmptyState as J, type PopupMenuGroupLabelProps as K, type LoaderComponentProps as L, type PopupMenuGroupLabelState as M, type NodeDef as N, type PopupMenuGroupProps as O, PopupMenuSurface as P, type QueryDependentLoaderConfig as Q, type PopupMenuGroupState as R, type StaticLoaderConfig as S, type PopupMenuIconProps as T, type PopupMenuIconState as U, type PopupMenuListChildrenState as V, type PopupMenuListProps as W, type PopupMenuListState as X, type PopupMenuPopupProps as Y, type PopupMenuPortalProps as Z, type PopupMenuScrollArrowProps as _, type PopupMenuSurfaceProps as a, type RadioGroupRenderProps as a$, type PopupMenuScrollDownArrowProps as a0, type PopupMenuScrollUpArrowProps as a1, type PopupMenuSeparatorProps as a2, type PopupMenuSeparatorState as a3, type PopupMenuSurfaceState as a4, PopupMenuListCssVars as a5, PopupMenuPositionerCssVars as a6, type PopupMenuCheckboxItemIndicatorProps as a7, type PopupMenuCheckboxItemIndicatorState as a8, type PopupMenuCheckboxItemProps as a9, type UsePopupMenuItemParams as aA, type UsePopupMenuItemReturn as aB, usePopupMenuItem as aC, type CheckboxItemDef as aD, type CheckboxItemRenderParams as aE, type CheckboxItemRenderProps as aF, type DataListChildrenState as aG, type DataListProps as aH, type DataSurfaceContextValue as aI, type DataSurfaceProps as aJ, type DeepSearchConfig as aK, type DisplayGroupNode as aL, type DisplayNode as aM, type DisplayRadioGroupNode as aN, type DisplayRowNode as aO, type GroupBehavior as aP, type GroupDef as aQ, type GroupRenderContext as aR, type GroupRenderParams as aS, type ItemDef as aT, type ItemRenderParams as aU, type ItemRenderProps as aV, type PopupMenuDataListProps as aW, type PopupMenuDataSurfaceProps as aX, type PopupMenuRadioGroupValueProps as aY, type RadioGroupDef as aZ, type RadioGroupRenderParams as a_, type PopupMenuCheckboxItemState as aa, type PopupMenuInputProps as ab, type PopupMenuInputState as ac, type PopupMenuItemProps as ad, type PopupMenuItemState as ae, type PopupMenuPositionerAlign as af, type PopupMenuPositionerProps as ag, type PopupMenuRadioGroupProps as ah, type PopupMenuRadioGroupState as ai, type PopupMenuRadioItemIndicatorProps as aj, type PopupMenuRadioItemIndicatorState as ak, type PopupMenuRadioItemProps as al, type PopupMenuRadioItemState as am, type PopupMenuShortcutProps as an, type PopupMenuShortcutState as ao, type PopupMenuSubmenuRootProps as ap, type PopupMenuSubmenuTriggerIndicatorProps as aq, type PopupMenuSubmenuTriggerIndicatorState as ar, type PopupMenuSubmenuTriggerProps as as, type PopupMenuSubmenuTriggerState as at, type PopupMenuContextValue as au, type SubmenuContextValue as av, useMaybePopupMenuContext as aw, useMaybeSubmenuContext as ax, usePopupMenuContext as ay, useSubmenuContext as az, PopupMenuArrow as b, type RenderNodeFn as b0, type RowRenderContext as b1, type ScoredNode as b2, type SeparatorDef as b3, type SubmenuDef as b4, type SubmenuRenderParams as b5, type SubmenuRenderProps as b6, DataSurfaceContext as b7, defineRadioGroup as b8, isDisplayGroupNode as b9, isDisplayRadioGroupNode as ba, isDisplayRowNode as bb, useDataSurfaceContext as bc, useMaybeDataSurfaceContext as bd, type AsyncLoaderConfig as be, type AsyncNodesConfig as bf, type AsyncRenderState as bg, type AsyncState as bh, type BreadcrumbNode as bi, type DisplaySeparatorNode as bj, type QueryAsyncNodesConfig as bk, type RadioGroupBehavior as bl, type RadioItemDef as bm, type RadioItemRenderParams as bn, type RadioItemRenderProps as bo, type SeparatorRenderParams as bp, type StaticAsyncNodesConfig as bq, isDisplaySeparatorNode as br, type VirtualizationConfig as bs, type VirtualAnchor as bt, type GetQualifiedRowIdContext as bu, PopupMenuContext as bv, SubmenuContext as bw, PopupMenuScrollArrow as bx, PopupMenuBackdrop as c, PopupMenuEmpty as d, PopupMenuGroup as e, PopupMenuGroupLabel as f, PopupMenuIcon as g, PopupMenuList as h, PopupMenuPopup as i, PopupMenuPortal as j, PopupMenuScrollDownArrow as k, PopupMenuScrollUpArrow as l, PopupMenuSeparator as m, PopupMenuCheckboxItem as n, PopupMenuCheckboxItemIndicator as o, PopupMenuInput as p, PopupMenuDataList as q, PopupMenuDataSurface as r, PopupMenuItem as s, PopupMenuPositioner as t, PopupMenuRadioGroup as u, PopupMenuRadioGroupValue as v, PopupMenuRadioItem as w, PopupMenuRadioItemIndicator as x, PopupMenuShortcut as y, PopupMenuSubmenuRoot as z };