@bazza-ui/react 0.0.0 → 0.1.0-canary.2

package/dist/data-surface-D1OilMDu.d.ts

@@ -0,0 +1,678 @@
+import * as React from 'react';
+import { PopoverPositionerProps, Popover, PopoverRootProps } from '@base-ui/react/popover';
+import { U as UseListboxItemParams, c as UseListboxItemReturn } from './use-listbox-item-BIi4eRPI.js';
+import { C as ComponentProps, A as AsyncLoaderConfig, t as AsyncLoaderResult, a2 as NodeDef, z as AsyncState, M as DeepSearchConfig, Y as IncludeInDeepSearch, G as GetQualifiedRowIdFn, O as DisplayNode, I as DataListProps, H as DataListChildrenState, K as DataSubpagesProps, J as DataSubpagesChildrenState, L as DataSurfaceProps } from './types-lQCIvWW8.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { r as RadioValueChangeEventDetails } from './events-BPr8sRGH.js';
+import { V as VirtualItem } from './ListboxStore-DPqpLlAL.js';
+import { a as PopupMenuRootActions } from './separator-B4Ot84B0.js';
+
+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 SubpageContextValue {
+    /** Current page ID. */
+    pageId: string;
+    /** Surface ID for this page. */
+    surfaceId: string;
+    /** Surface ID for the previous page, if available. */
+    parentSurfaceId: string | null;
+    /** Whether this page is currently active. */
+    isActive: boolean;
+    /** Whether Escape should close the entire menu tree from this page. */
+    closeRootOnEsc: boolean;
+    /** Navigate back one page. Returns true when navigation happened. */
+    goBack: () => boolean;
+}
+declare const SubpageContext: React.Context<SubpageContextValue | null>;
+declare function useSubpageContext(): SubpageContextValue;
+declare function useMaybeSubpageContext(): SubpageContextValue | null;
+
+declare const ROOT_SUBPAGE_ID = "__root__";
+interface SubpageRegistration {
+    pageId: string;
+    surfaceId: string;
+    closeRootOnEsc: boolean;
+}
+interface SubpageStackContextValue {
+    /** Currently active page ID. */
+    activePageId: string;
+    /** Surface ID for the currently active page. */
+    activeSurfaceId: string;
+    /** Whether there is a previous page to navigate back to. */
+    canGoBack: boolean;
+    /** Whether Escape in the active page should close the entire menu tree. */
+    shouldCloseRootOnEsc: boolean;
+    /** Current page stack from root to active page. */
+    stack: readonly string[];
+    /** Register a page and return an unregister cleanup. */
+    registerPage: (registration: SubpageRegistration) => () => void;
+    /** Push a page onto the stack. Returns true when navigation happened. */
+    openPage: (pageId: string) => boolean;
+    /** Pop one page from the stack. Returns true when navigation happened. */
+    goBack: () => boolean;
+    /** Resolve a surface ID for a page ID. */
+    getSurfaceId: (pageId: string) => string | null;
+}
+declare const SubpageStackContext: React.Context<SubpageStackContextValue | null>;
+declare function useSubpageStack(): SubpageStackContextValue;
+declare function useMaybeSubpageStack(): SubpageStackContextValue | null;
+
+/**
+ * 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;
+}
+interface UsePopupMenuItemReturn extends UseListboxItemReturn {
+    /** Whether this item is effectively disabled (item disabled OR menu disabled). */
+    disabled: boolean;
+}
+/**
+ * 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 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 {
+    }
+}
+
+/**
+ * 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' | 'actionsRef'> {
+    /**
+     * 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).
+     */
+    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;
+    /**
+     * Whether this submenu should ignore user interaction.
+     * Also inherits disabled state from its parent menu.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * A ref to imperative actions.
+     * - `close`: closes the submenu imperatively.
+     * - `unmount`: unmounts the popup imperatively (when keep-mounted mode is enabled).
+     * - `setDisabled`: enables/disables the submenu imperatively.
+     */
+    actionsRef?: React.RefObject<PopupMenuSubmenuRoot.Actions | null>;
+    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 = PopupMenuRootActions;
+}
+
+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 PopupMenuSubpageProps {
+    /** Unique page ID for stack navigation. */
+    pageId: string;
+    /**
+     * Whether pressing Escape in this page closes the entire menu tree.
+     * When false (default), Escape navigates back one page.
+     * @default false
+     */
+    closeRootOnEsc?: boolean;
+    children: React.ReactNode;
+}
+/**
+ * Groups all parts of a subpage.
+ * Creates an isolated menu surface that renders in the same popup and
+ * participates in push/pop page stack navigation.
+ * Doesn't render its own HTML element.
+ */
+declare function PopupMenuSubpage(props: PopupMenuSubpageProps): react_jsx_runtime.JSX.Element;
+declare namespace PopupMenuSubpage {
+    interface Props extends PopupMenuSubpageProps {
+    }
+}
+
+interface PopupMenuSubpageBackState extends Record<string, unknown> {
+    /** Whether navigating back is currently possible. */
+    canGoBack: boolean;
+    /** Whether the button is disabled. */
+    disabled: boolean;
+}
+interface PopupMenuSubpageBackProps extends ComponentProps<'button', PopupMenuSubpageBack.State> {
+    /** Whether this button is disabled. */
+    disabled?: boolean;
+}
+/**
+ * A button that navigates back one page in the current subpage stack.
+ * Useful for custom headers/toolbars outside of list rows.
+ * Renders a `<button>` element.
+ */
+declare const PopupMenuSubpageBack: React.ForwardRefExoticComponent<Omit<PopupMenuSubpageBack.Props, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare namespace PopupMenuSubpageBack {
+    type State = PopupMenuSubpageBackState;
+    interface Props extends PopupMenuSubpageBackProps {
+    }
+}
+
+interface PopupMenuSubpageBackItemState extends Record<string, unknown> {
+    /** Whether this is a subpage back item (always true). */
+    subpageBackItem: boolean;
+    /** Whether the item is highlighted. */
+    highlighted: boolean;
+    /** Whether the item is disabled. */
+    disabled: boolean;
+}
+interface PopupMenuSubpageBackItemProps extends ComponentProps<'div', PopupMenuSubpageBackItem.State> {
+    /** Explicit unique identifier for this item in the store. */
+    id?: string;
+    /** Unique value for this item used for filtering. */
+    value?: string;
+    /** Additional keywords to match against when filtering. */
+    keywords?: string[];
+    /** Whether this item is disabled. */
+    disabled?: boolean;
+    /** Whether to force render this item regardless of filter results. */
+    forceMount?: boolean;
+    /** Callback when this item is selected. */
+    onSelect?: () => void;
+    /**
+     * Async callback when this item is selected.
+     *
+     * When provided, this takes precedence over `onSelect`.
+     * If provided, this callback is awaited before navigating back.
+     * Return `false` to prevent automatic navigation.
+     */
+    onSelectAsync?: (context: PopupMenuSubpageBackItem.OnSelectAsyncContext) => Promise<void | boolean>;
+}
+/**
+ * A list row that navigates back one page in the current subpage stack.
+ * Renders a `<div>` element with role="option".
+ */
+declare const PopupMenuSubpageBackItem: React.ForwardRefExoticComponent<Omit<PopupMenuSubpageBackItem.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuSubpageBackItem {
+    type State = PopupMenuSubpageBackItemState;
+    interface OnSelectAsyncContext {
+        /** Navigate back one page manually. */
+        goBack: () => boolean;
+        /** Aborts when a pending async selection is canceled or unmounted. */
+        signal: AbortSignal;
+    }
+    interface Props extends PopupMenuSubpageBackItemProps {
+    }
+}
+
+/**
+ * State for a registered async loader.
+ */
+interface AsyncMenuState {
+    /** Unique identifier for this async menu */
+    id: string;
+    /** Breadcrumbs path to this menu (for merging into tree) */
+    breadcrumbs: string[];
+    /** The loader configuration */
+    config: AsyncLoaderConfig;
+    /** Current loader result */
+    result: AsyncLoaderResult<NodeDef[]>;
+}
+/**
+ * Context value for the async menu coordinator.
+ */
+interface AsyncMenuCoordinatorValue {
+    /** Register a new async loader */
+    registerLoader: (state: AsyncMenuState) => void;
+    /** Unregister an async loader */
+    unregisterLoader: (id: string) => void;
+    /** Update loader result */
+    updateLoaderResult: (id: string, result: AsyncLoaderResult<NodeDef[]>) => void;
+    /** Current search query from the store */
+    searchQuery: string;
+    /** All registered loaders */
+    loaders: Map<string, AsyncMenuState>;
+    /** Any loader is currently in initial loading phase */
+    isAnyLoading: boolean;
+    /** Any loader is currently fetching (initial or background) */
+    isAnyFetching: boolean;
+    /** Any loader is currently in first-load phase */
+    isAnyInitialLoading: boolean;
+    /** Any loader is currently in background refetch phase */
+    isAnyRefetching: boolean;
+    /** All registered loaders are currently in background refetch phase */
+    isAllRefetching: boolean;
+    /** The root (__root__) loader is currently in initial loading phase */
+    isRootLoading: boolean;
+    /** Static loaders are currently in initial loading phase */
+    isStaticLoading: boolean;
+    /** Static loaders are currently fetching */
+    isStaticFetching: boolean;
+    /** Static loaders in first-load phase */
+    isStaticInitialLoading: boolean;
+    /** Static loaders in background refetch phase */
+    isStaticRefetching: boolean;
+    /** Query loaders are currently in initial loading phase */
+    isQueryLoading: boolean;
+    /** Query loaders are currently fetching */
+    isQueryFetching: boolean;
+    /** Query loaders in first-load phase */
+    isQueryInitialLoading: boolean;
+    /** Query loaders in background refetch phase */
+    isQueryRefetching: boolean;
+    /** All loaders have resolved (not fetching) */
+    allResolved: boolean;
+    /** Get all resolved async nodes with their breadcrumbs */
+    getAsyncNodes: () => Array<{
+        id: string;
+        breadcrumbs: string[];
+        nodes: NodeDef[];
+    }>;
+    /** Loaders that errored */
+    erroredLoaders: Map<string, Error>;
+    /** Get the aggregate async state for DataList */
+    getAsyncState: () => AsyncState;
+}
+declare const AsyncMenuCoordinatorContext: React.Context<AsyncMenuCoordinatorValue | null>;
+declare function useAsyncMenuCoordinator(): AsyncMenuCoordinatorValue | null;
+declare function useMaybeAsyncMenuCoordinator(): AsyncMenuCoordinatorValue | null;
+interface AsyncMenuCoordinatorProviderProps {
+    /** Children to render */
+    children: React.ReactNode;
+    /** Current search query from the store */
+    searchQuery: string;
+}
+declare function AsyncMenuCoordinatorProvider(props: AsyncMenuCoordinatorProviderProps): react_jsx_runtime.JSX.Element;
+
+interface DataSurfaceContextValue {
+    /** The original node definitions */
+    content: NodeDef[];
+    /** Async content configuration for root-level async loading */
+    asyncContent?: AsyncLoaderConfig;
+    /** Deep search configuration */
+    deepSearchConfig: DeepSearchConfig;
+    /** Default submenu inclusion mode for deep search */
+    includeInDeepSearch: IncludeInDeepSearch;
+    /** 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>;
+interface DataPopupContextValue {
+    /** Latest DataSurface context registered within this popup. */
+    dataSurfaceContext: DataSurfaceContextValue | null;
+    /** Registers/clears DataSurface context for sibling consumers. */
+    setDataSurfaceContext: React.Dispatch<React.SetStateAction<DataSurfaceContextValue | null>>;
+}
+declare const DataPopupContext: React.Context<DataPopupContextValue | null>;
+declare function useDataSurfaceContext(): DataSurfaceContextValue;
+declare function useMaybeDataSurfaceContext(): DataSurfaceContextValue | null;
+declare function useDataPopupContext(): DataPopupContextValue;
+declare function useMaybeDataPopupContext(): DataPopupContextValue | 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 PopupMenuDataSubpagesProps extends DataSubpagesProps {
+}
+/**
+ * DataSubpages renders subpage content alongside the root Surface inside Popup.
+ *
+ * Place it as a sibling to DataSurface within Popup:
+ *
+ * ```tsx
+ * <Popup>
+ *   <DataSurface ...>
+ *     ...
+ *   </DataSurface>
+ *   <DataSubpages />
+ * </Popup>
+ * ```
+ */
+declare function PopupMenuDataSubpages(props: PopupMenuDataSubpagesProps): react_jsx_runtime.JSX.Element | null;
+declare namespace PopupMenuDataSubpages {
+    interface Props extends PopupMenuDataSubpagesProps {
+    }
+    type ChildrenState = DataSubpagesChildrenState;
+}
+
+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 { SubmenuContext as $, type PopupMenuSubpageBackItemState as A, type PopupMenuSubpageBackProps as B, type PopupMenuSubpageBackState as C, type PopupMenuSubpageProps as D, type SubpageContextValue as E, type SubpageStackContextValue as F, useMaybeSubmenuContext as G, useMaybeSubpageContext as H, useMaybeSubpageStack as I, useSubmenuContext as J, useSubpageContext as K, useSubpageStack as L, type UsePopupMenuItemReturn as M, usePopupMenuItem as N, type AsyncMenuCoordinatorValue as O, PopupMenuCheckboxItemIndicator as P, type DataSurfaceContextValue as Q, type PopupMenuDataListProps as R, type SubmenuContextValue as S, type PopupMenuDataSubpagesProps as T, type UsePopupMenuItemParams as U, type PopupMenuDataSurfaceProps as V, type PopupMenuRadioGroupValueProps as W, type RenderNodeFn as X, DataSurfaceContext as Y, useDataSurfaceContext as Z, useMaybeDataSurfaceContext as _, PopupMenuDataList as a, SubpageContext as a0, type SubpageRegistration as a1, ROOT_SUBPAGE_ID as a2, SubpageStackContext as a3, type AsyncMenuState as a4, AsyncMenuCoordinatorContext as a5, AsyncMenuCoordinatorProvider as a6, type DataPopupContextValue as a7, DataPopupContext as a8, useDataPopupContext as a9, useMaybeDataPopupContext as aa, PopupMenuDataSubpages as b, PopupMenuDataSurface as c, PopupMenuPositioner as d, PopupMenuRadioGroupValue as e, PopupMenuRadioItemIndicator as f, PopupMenuShortcut as g, PopupMenuSubmenuRoot as h, PopupMenuSubmenuTriggerIndicator as i, PopupMenuSubpage as j, PopupMenuSubpageBack as k, PopupMenuSubpageBackItem as l, useMaybeAsyncMenuCoordinator as m, type PopupMenuCheckboxItemIndicatorProps as n, type PopupMenuCheckboxItemIndicatorState as o, type PopupMenuPositionerAlign as p, type PopupMenuPositionerProps as q, type PopupMenuRadioItemIndicatorProps as r, type PopupMenuRadioItemIndicatorState as s, type PopupMenuShortcutProps as t, useAsyncMenuCoordinator as u, type PopupMenuShortcutState as v, type PopupMenuSubmenuRootProps as w, type PopupMenuSubmenuTriggerIndicatorProps as x, type PopupMenuSubmenuTriggerIndicatorState as y, type PopupMenuSubpageBackItemProps as z };