@bazza-ui/react 0.0.0-snapshot-20260205122957

package/dist/use-listbox-item-bi01_uzf.d.ts

@@ -0,0 +1,659 @@
+import { ReactStore } from '@base-ui/utils/store';
+import * as React$1 from 'react';
+
+declare const triggerPress: "trigger-press";
+declare const triggerHover: "trigger-hover";
+declare const triggerFocus: "trigger-focus";
+declare const triggerContextMenu: "trigger-context-menu";
+declare const escapeKey: "escape-key";
+declare const outsidePress: "outside-press";
+declare const focusOut: "focus-out";
+declare const itemPress: "item-press";
+declare const itemKeyboardSelect: "item-keyboard-select";
+declare const closePress: "close-press";
+declare const inputChange: "input-change";
+declare const inputClear: "input-clear";
+declare const clearPress: "clear-press";
+declare const listNavigation: "list-navigation";
+declare const submenuTrigger: "submenu-trigger";
+declare const siblingOpen: "sibling-open";
+declare const pointer: "pointer";
+declare const keyboard: "keyboard";
+declare const auto: "auto";
+declare const imperativeAction: "imperative-action";
+declare const none: "none";
+
+/**
+ * Maps event reason strings to their corresponding native DOM event types.
+ * This provides type-safe access to the native event based on the reason.
+ */
+interface ReasonToEventMap {
+    [none]: Event;
+    [triggerPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
+    [triggerHover]: MouseEvent | PointerEvent;
+    [triggerFocus]: FocusEvent;
+    [triggerContextMenu]: MouseEvent;
+    [escapeKey]: KeyboardEvent;
+    [outsidePress]: MouseEvent | PointerEvent | TouchEvent;
+    [focusOut]: FocusEvent | KeyboardEvent;
+    [itemPress]: MouseEvent | PointerEvent | KeyboardEvent;
+    [itemKeyboardSelect]: KeyboardEvent;
+    [closePress]: MouseEvent | PointerEvent | KeyboardEvent;
+    [inputChange]: InputEvent | Event;
+    [inputClear]: InputEvent | FocusEvent | Event;
+    [clearPress]: MouseEvent | PointerEvent | KeyboardEvent;
+    [listNavigation]: KeyboardEvent;
+    [submenuTrigger]: MouseEvent | PointerEvent | KeyboardEvent;
+    [siblingOpen]: Event;
+    [pointer]: MouseEvent | PointerEvent;
+    [keyboard]: KeyboardEvent;
+    [imperativeAction]: Event;
+}
+/**
+ * Maps a reason string to the corresponding native event type.
+ * Falls back to `Event` for unknown reasons.
+ */
+type ReasonToEvent<Reason extends string> = Reason extends keyof ReasonToEventMap ? ReasonToEventMap[Reason] : Event;
+/**
+ * Details object passed to change event handlers (onOpenChange, onValueChange, etc.)
+ *
+ * @template Reason - The union of allowed reason strings for this event
+ * @template CustomProperties - Additional component-specific properties
+ */
+interface ChangeEventDetails<Reason extends string, CustomProperties extends object = {}> {
+    /**
+     * The reason why this state change occurred.
+     * Use this to conditionally handle different scenarios.
+     *
+     * @example
+     * ```tsx
+     * onOpenChange={(open, details) => {
+     *   if (details.reason === 'escape-key') {
+     *     // Handle escape key differently
+     *   }
+     * }}
+     * ```
+     */
+    reason: Reason;
+    /**
+     * The native DOM event that triggered this change.
+     * May be a synthetic event in some cases.
+     */
+    event: ReasonToEvent<Reason>;
+    /**
+     * Cancels the state change.
+     * When called, the component's internal state will not update.
+     *
+     * @example
+     * ```tsx
+     * onOpenChange={(open, details) => {
+     *   if (!open && details.reason === 'outside-press') {
+     *     details.cancel() // Prevent closing on outside press
+     *   }
+     * }}
+     * ```
+     */
+    cancel: () => void;
+    /**
+     * Allows the native event to propagate.
+     * By default, some events (like Escape key) stop propagation
+     * to prevent parent popups from closing simultaneously.
+     */
+    allowPropagation: () => void;
+    /**
+     * Whether `cancel()` has been called.
+     */
+    readonly isCanceled: boolean;
+    /**
+     * Whether `allowPropagation()` has been called.
+     */
+    readonly isPropagationAllowed: boolean;
+    /**
+     * The element that triggered this event, if applicable.
+     */
+    trigger: Element | undefined;
+}
+/**
+ * Details object for generic events that don't support cancellation.
+ * Used for events like onHighlightChange where cancellation doesn't make sense.
+ *
+ * @template Reason - The union of allowed reason strings for this event
+ * @template CustomProperties - Additional component-specific properties
+ */
+interface GenericEventDetails<Reason extends string, CustomProperties extends object = {}> {
+    /**
+     * The reason why this event occurred.
+     */
+    reason: Reason;
+    /**
+     * The native DOM event that triggered this event.
+     */
+    event: ReasonToEvent<Reason>;
+}
+
+/**
+ * Reasons why a popup menu's open state changed.
+ */
+type PopupMenuOpenChangeReason = typeof triggerPress | typeof triggerHover | typeof triggerFocus | typeof triggerContextMenu | typeof escapeKey | typeof outsidePress | typeof focusOut | typeof itemPress | typeof closePress | typeof listNavigation | typeof submenuTrigger | typeof siblingOpen | typeof imperativeAction | typeof none;
+/**
+ * Event details for popup menu open state changes.
+ */
+type PopupMenuOpenChangeEventDetails = ChangeEventDetails<PopupMenuOpenChangeReason>;
+/**
+ * Reasons why highlight changed.
+ */
+type HighlightChangeReason = typeof pointer | typeof keyboard | typeof auto | typeof none;
+/**
+ * Event details for highlight changes.
+ */
+type HighlightChangeEventDetails = GenericEventDetails<HighlightChangeReason, {
+    index: number;
+}>;
+/**
+ * Reasons why a checkbox item's checked state changed.
+ */
+type CheckedChangeReason = typeof itemPress | typeof itemKeyboardSelect;
+/**
+ * Event details for checkbox item checked state changes.
+ */
+type CheckedChangeEventDetails = ChangeEventDetails<CheckedChangeReason>;
+/**
+ * Reasons why a radio group's value changed.
+ */
+type RadioValueChangeReason = typeof itemPress | typeof itemKeyboardSelect;
+/**
+ * Event details for radio group value changes.
+ */
+type RadioValueChangeEventDetails = ChangeEventDetails<RadioValueChangeReason>;
+
+interface ItemContextValue {
+    /** Unique ID for this item (for DOM id attribute) */
+    id: string;
+    /** Whether the item is highlighted */
+    highlighted: boolean;
+    /** Whether the item is disabled */
+    disabled: boolean;
+    /** Keyboard shortcut for this item */
+    shortcut?: string;
+}
+declare const ItemContext: React$1.Context<ItemContextValue | null>;
+declare function useItemContext(): ItemContextValue;
+declare function useMaybeItemContext(): ItemContextValue | null;
+
+type FilterFn = (value: string, search: string, keywords?: string[]) => number;
+interface ItemRegistration {
+    value: string;
+    keywords?: string[];
+    groupId?: string;
+    disabled?: boolean;
+    /** Whether this item is a submenu trigger */
+    isSubmenuTrigger?: boolean;
+    /** Single character keyboard shortcut to trigger this item */
+    shortcut?: string;
+    /** Whether selecting this item should close the menu (default: true) */
+    closeOnClick?: boolean;
+}
+/**
+ * Pre-registered item for virtualization.
+ * This allows the store to know about all items even when they're not mounted.
+ * The `value` field serves as both the unique identifier and the filtering value.
+ */
+interface VirtualItem {
+    /** Value used as unique identifier and for filtering/matching */
+    value: string;
+    /** Additional keywords for filtering */
+    keywords?: string[];
+    /** Whether the item is disabled */
+    disabled?: boolean;
+}
+type HighlightSource = 'keyboard' | 'pointer' | 'auto' | null;
+/**
+ * Refs for DOM elements used for scroll behavior.
+ * These are stored outside of reactive state to avoid unnecessary re-renders.
+ */
+interface DOMRefs {
+    /** Ref to the list/scroll container element */
+    listRef: React.RefObject<HTMLElement | null>;
+    /** Map of item ID to ref for the item's DOM element */
+    itemRefs: Map<string, React.RefObject<HTMLElement | null>>;
+}
+interface ListboxState {
+    /** Whether the listbox is open */
+    open: boolean;
+    /** Current search query */
+    search: string;
+    /** Currently highlighted item ID */
+    highlightedId: string | null;
+    /** Source of the current highlight (keyboard or pointer) */
+    highlightSource: HighlightSource;
+    /** Whether an Input is present in the Surface */
+    hasInput: boolean;
+    /** Whether the input is currently active (rendered) when hideUntilActive mode is used */
+    inputActive: boolean;
+    /** Pending search character typed before input was active */
+    pendingSearch: string;
+    /** Filtered results: item ID to score */
+    filteredItems: Map<string, number>;
+    /** Groups that have at least one visible item */
+    visibleGroups: Set<string>;
+    /** Count of visible items */
+    filteredCount: number;
+    /** Counter to trigger re-filtering when items change */
+    filterTrigger: number;
+    /** Whether virtualization mode is enabled */
+    virtualized: boolean;
+    /** Count of virtual items (from items prop) */
+    virtualItemsCount: number;
+}
+interface ListboxContext {
+    /** Filter function or false to disable filtering */
+    filter: FilterFn | false;
+    /** Whether to loop navigation */
+    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
+     */
+    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 (requires Surface to call clearSearch)
+     */
+    clearSearchOnClose: boolean | 'after-exit';
+    /** Whether hideUntilActive mode is enabled */
+    hideUntilActive: boolean;
+    /** ID for the list element (for aria-activedescendant) */
+    listId: string;
+    /** ID for the input element */
+    inputId: string;
+    /** Map of item ID to registration data */
+    readonly items: Map<string, ItemRegistration>;
+    /** Map of group ID to set of item IDs */
+    readonly groups: Map<string, Set<string>>;
+    /** Map of item ID to onSelect callback */
+    readonly itemSelects: Map<string, () => void>;
+    /** Map of submenu trigger ID to open callback */
+    readonly submenuOpens: Map<string, () => void>;
+    /** Map of submenu trigger ID to close callback */
+    readonly submenuCloses: Map<string, () => void>;
+    /** Map of shortcut key to item ID */
+    readonly shortcuts: Map<string, string>;
+    /**
+     * Callback when open state changes.
+     * The second parameter contains event details including the reason for the change.
+     */
+    onOpenChange: (open: boolean, eventDetails: PopupMenuOpenChangeEventDetails) => void;
+    /** Callback when search state changes */
+    onSearchChange: ((search: string) => void) | undefined;
+    /**
+     * Pre-registered items for virtualization.
+     * When provided, navigation uses this array order instead of DOM registration order.
+     */
+    virtualItems: VirtualItem[];
+    /**
+     * Consumer-provided ordered list of item values when filter={false}.
+     * Used to determine correct navigation/highlight order when consumer handles filtering externally.
+     * Must always be provided when filter={false}.
+     */
+    orderedItems: string[];
+    /**
+     * Callback when highlighted item changes and needs scroll sync.
+     * Called only when the item is not in the DOM (virtualized out of view).
+     * Useful for synchronizing with virtualizers (scrollToIndex).
+     * The third parameter contains event details including the reason for the change.
+     */
+    onHighlightChange: ((id: string | null, index: number, eventDetails: HighlightChangeEventDetails) => void) | undefined;
+    /**
+     * DOM refs for scroll behavior.
+     * Stored in context (not state) to avoid re-renders.
+     */
+    refs: DOMRefs;
+    /**
+     * Callback when menu close animation completes.
+     * Used for resetting row width measurements.
+     */
+    onCloseComplete?: () => void;
+    /**
+     * Last known pointer position for detecting actual pointer movement.
+     * Used to prevent "phantom" highlights when content shifts under a stationary pointer.
+     */
+    lastPointerPosition: {
+        x: number;
+        y: number;
+    } | null;
+}
+declare const selectors: {
+    open: (state: ListboxState) => boolean;
+    search: (state: ListboxState) => string;
+    highlightedId: (state: ListboxState) => string | null;
+    highlightSource: (state: ListboxState) => HighlightSource;
+    hasInput: (state: ListboxState) => boolean;
+    inputActive: (state: ListboxState) => boolean;
+    pendingSearch: (state: ListboxState) => string;
+    filteredCount: (state: ListboxState) => number;
+    filteredItems: (state: ListboxState) => Map<string, number>;
+    visibleGroups: (state: ListboxState) => Set<string>;
+    virtualized: (state: ListboxState) => boolean;
+    isHighlighted: (state: ListboxState, itemId: string) => boolean;
+    isGroupVisible: (state: ListboxState, groupId: string) => boolean;
+    getItemScore: (state: ListboxState, itemId: string) => number;
+    hasSearchWithNoResults: (state: ListboxState) => boolean;
+};
+/**
+ * Core store for listbox-like components.
+ * Handles item registration, filtering, navigation, and highlight state.
+ *
+ * Used by: DropdownMenu, ContextMenu, Select, CommandMenu
+ */
+declare class ListboxStore extends ReactStore<ListboxState, ListboxContext, typeof selectors> {
+    constructor(initialState?: Partial<ListboxState>, context?: Partial<ListboxContext>);
+    /**
+     * Set the open state with event details.
+     *
+     * @param open - The new open state
+     * @param reason - The reason for the state change (default: 'none')
+     * @param event - The native DOM event that triggered the change (optional)
+     */
+    setOpen(open: boolean, reason?: PopupMenuOpenChangeReason, event?: Event): void;
+    setSearch(search: string): void;
+    setHighlightedId(id: string | null, cause?: HighlightSource): void;
+    /**
+     * Notify listeners about highlight changes.
+     * Called whenever highlightedId changes, regardless of virtualization or DOM state.
+     * Useful for virtualization scroll sync, analytics, or any other tracking needs.
+     *
+     * @param id - The newly highlighted item ID (or null if cleared)
+     * @param cause - What caused the highlight change
+     */
+    private notifyHighlightChange;
+    /**
+     * Scroll the highlighted item into view.
+     * Uses native scrollIntoView if the element is in the DOM.
+     * For virtualized lists, the onHighlightChange callback (called from setHighlightedId)
+     * should handle scrolling via the virtualizer.
+     *
+     * @param id - The item ID to scroll into view
+     */
+    private scrollItemIntoView;
+    setHasInput(hasInput: boolean): void;
+    setInputActive(active: boolean): void;
+    setPendingSearch(search: string): void;
+    setHideUntilActive(enabled: boolean): void;
+    setVirtualized(virtualized: boolean): void;
+    setVirtualItems(items: VirtualItem[]): void;
+    /**
+     * Set the consumer-provided ordered items.
+     * Used when filter={false} and consumer controls item order/visibility.
+     * Must always be provided when filter={false}.
+     *
+     * @param items - Array of item IDs in display order
+     */
+    setOrderedItems(items: string[]): void;
+    /**
+     * Try to auto-highlight when an item registers.
+     * This handles the case where orderedItems was set before items mounted.
+     * Only highlights if:
+     * - filter={false} (using orderedItems)
+     * - Menu is open
+     * - No item is currently highlighted
+     * - autoHighlightFirst is enabled
+     * - The registering item is the first in orderedItems
+     */
+    private maybeAutoHighlightOnRegister;
+    setOnHighlightChange(callback: ((id: string | null, index: number, eventDetails: HighlightChangeEventDetails) => void) | undefined): void;
+    /**
+     * Set the list element ref for scroll container detection.
+     */
+    setListRef(ref: React.RefObject<HTMLElement | null>): void;
+    /**
+     * Register an item's DOM ref for scrollIntoView behavior.
+     * Returns a cleanup function.
+     */
+    registerItemRef(id: string, ref: React.RefObject<HTMLElement | null>): () => void;
+    /**
+     * Check if pointer has moved and should allow highlight.
+     * This prevents "phantom" highlights when content shifts under a stationary pointer
+     * (e.g., when search results change or menu items reorder).
+     *
+     * @param x - Current pointer X position
+     * @param y - Current pointer Y position
+     * @returns true if pointer has actually moved and highlight should be allowed
+     */
+    shouldAllowPointerHighlight(x: number, y: number): boolean;
+    /**
+     * Reset pointer position tracking.
+     * Call this when the menu opens or content changes significantly.
+     */
+    resetPointerPosition(): void;
+    /**
+     * Pre-register virtual items so they appear in filteredItems.
+     * This allows filtering to work for items that aren't mounted yet.
+     */
+    private preRegisterVirtualItems;
+    registerItem(id: string, registration: ItemRegistration): () => void;
+    registerGroup(id: string): () => void;
+    registerItemSelect(id: string, onSelect: (() => void) | undefined): () => void;
+    registerSubmenuOpen(id: string, onOpen: (() => void) | undefined): () => void;
+    registerSubmenuClose(id: string, onClose: (() => void) | undefined): () => void;
+    /**
+     * Close all submenus except the one with the given ID.
+     * Used when hovering over a new submenu trigger to close sibling submenus.
+     */
+    closeSiblingSubmenus(exceptId: string | null): void;
+    highlightNext(): void;
+    highlightPrev(): void;
+    selectHighlighted(): void;
+    /**
+     * Select an item by its keyboard shortcut.
+     * Returns true if an item was found and selected, false otherwise.
+     */
+    selectByShortcut(key: string): boolean;
+    openSubmenuForHighlighted(): void;
+    isHighlightedSubmenuTrigger(): boolean;
+    /**
+     * Get the item registration for the highlighted item.
+     * Returns undefined if no item is highlighted.
+     */
+    getHighlightedItem(): ItemRegistration | undefined;
+    clearSearch(): void;
+    highlightFirstItem(): void;
+    /**
+     * Apply auto-highlight based on the current context.autoHighlightFirst value.
+     * Called by Surface after updating the context to ensure correct value is used.
+     */
+    applyAutoHighlight(): void;
+    /**
+     * Highlight a specific item by its value.
+     * If the item is not visible or doesn't exist, falls back to highlighting the first item.
+     * Scrolls the highlighted item into view.
+     */
+    highlightItemByValue(value: string): void;
+    /**
+     * Returns whether filtering is disabled (consumer handles filtering externally).
+     */
+    isFilterDisabled(): boolean;
+    getVisibleItemIds(): string[];
+    /**
+     * Get the index of an item in the visible items list.
+     * Returns -1 if the item is not found or not visible.
+     */
+    getVisibleItemIndex(id: string): number;
+    /**
+     * Get the index of an item in the virtualItems array.
+     * This is used for virtualizer scrollToIndex which needs the raw array index,
+     * not the filtered/visible index.
+     * Returns -1 if not found or not in virtualized mode.
+     */
+    getVirtualItemIndex(value: string): number;
+    /**
+     * Validates and updates the highlighted item.
+     * This is the single source of truth for highlight management.
+     *
+     * @param options.forceFirst - Force highlight first item even if current is valid
+     * @param options.filteredItems - Use this map instead of state (for mid-update calls)
+     * @param options.newSearch - The search query for filteredItems (to detect search cleared)
+     */
+    private validateHighlight;
+    private recomputeFilteredItems;
+    static useStore(externalStore: ListboxStore | undefined, initialState?: Partial<ListboxState>, context?: Partial<ListboxContext>): ListboxStore;
+}
+
+/**
+ * Aim guard refs for submenu navigation.
+ * Optional - only needed for popup menus with submenus.
+ */
+interface AimGuardRefs {
+    /** Whether aim guard is currently active */
+    aimGuardActiveRef: React$1.RefObject<boolean>;
+    /** The depth at which aim guard is active (null when not guarding) */
+    guardedDepthRef: React$1.RefObject<number | null>;
+}
+/**
+ * Parameters for the useListboxItem hook.
+ */
+interface UseListboxItemParams {
+    /**
+     * Explicit unique identifier for this item in the store.
+     * Takes highest priority for item registration.
+     * Used by data-first APIs to ensure consistent IDs.
+     */
+    id?: string;
+    /**
+     * Unique value for this item used as identifier and for filtering.
+     * If not provided, will be inferred from textContent.
+     * Used for registration when `id` is not provided.
+     */
+    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;
+    /**
+     * 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;
+    /**
+     * Whether this item is a submenu trigger (for store registration).
+     * @default false
+     */
+    isSubmenuTrigger?: boolean;
+    /**
+     * Callback when this item is selected (via click or Enter key).
+     * For simple items, pass this directly. For checkbox/radio items,
+     * use registerSelect() to register a dynamic handler.
+     */
+    onSelect?: () => void;
+    /**
+     * Whether selecting this item should close the menu.
+     * @default true
+     */
+    closeOnClick?: boolean;
+    /**
+     * Callback invoked after selection occurs (via click).
+     * Called with the item's ID. The consumer handles any
+     * post-selection behavior like closing menus.
+     */
+    onAfterSelect?: (itemId: string) => void;
+    /**
+     * Children (used for text content inference when value is not provided).
+     */
+    children?: React$1.ReactNode;
+    /**
+     * Optional aim guard refs for popup menu navigation.
+     * When provided, pointer move events will respect the aim guard.
+     */
+    aimGuard?: AimGuardRefs;
+}
+/**
+ * Return value from the useListboxItem hook.
+ */
+interface UseListboxItemReturn {
+    /** Unique ID for this item (DOM ID for aria-activedescendant) */
+    id: string;
+    /**
+     * Store identifier for this item.
+     * Use this when calling store methods like setHighlightedId, registerSubmenuOpen, etc.
+     * This is the `value` prop (or inferred from textContent).
+     */
+    storeId: string;
+    /** Ref to attach to the item element */
+    ref: React$1.RefObject<HTMLDivElement | null>;
+    /** Whether item is currently highlighted */
+    isHighlighted: boolean;
+    /** Whether item should be rendered (passes filter) */
+    isVisible: boolean;
+    /** Context value to provide to children via ItemContext.Provider */
+    contextValue: ItemContextValue;
+    /**
+     * Event handlers to spread on the element.
+     * These handle click, pointer move, and pointer down events.
+     */
+    handlers: {
+        onClick: React$1.MouseEventHandler<HTMLDivElement>;
+        onPointerMove: React$1.PointerEventHandler<HTMLDivElement>;
+        onPointerDown: React$1.PointerEventHandler<HTMLDivElement>;
+    };
+    /**
+     * Register a custom onSelect handler.
+     * This is useful for checkbox/radio items where the select behavior
+     * needs to be customized (e.g., toggle checked state).
+     * Returns an unregister function.
+     */
+    registerSelect: (handler: (() => void) | undefined) => () => void;
+}
+/**
+ * Hook that provides all shared logic for navigatable/highlightable listbox items.
+ *
+ * This hook handles:
+ * - Item registration with the listbox store
+ * - Highlight state management (keyboard and pointer)
+ * - Filter/search visibility
+ * - Scroll into view on keyboard navigation
+ * - Click, pointer move, and pointer down event handlers
+ * - Optional aim guard integration (for submenu navigation)
+ *
+ * @example
+ * ```tsx
+ * function CustomItem(props) {
+ *   const item = useListboxItem({
+ *     value: props.value,
+ *     disabled: props.disabled,
+ *     onSelect: props.onSelect,
+ *   })
+ *
+ *   if (!item.isVisible) return null
+ *
+ *   return (
+ *     <ItemContext.Provider value={item.contextValue}>
+ *       <div
+ *         ref={item.ref}
+ *         {...item.handlers}
+ *         data-highlighted={item.isHighlighted || undefined}
+ *       >
+ *         {props.children}
+ *       </div>
+ *     </ItemContext.Provider>
+ *   )
+ * }
+ * ```
+ */
+declare function useListboxItem(params: UseListboxItemParams): UseListboxItemReturn;
+
+export { type AimGuardRefs as A, type HighlightSource as B, type ChangeEventDetails as C, type DOMRefs as D, type CheckedChangeReason as E, type FilterFn as F, type GenericEventDetails as G, type HighlightChangeEventDetails as H, type ItemRegistration as I, type CheckedChangeEventDetails as J, type RadioValueChangeEventDetails as K, type ListboxContext as L, type PopupMenuOpenChangeReason as P, type RadioValueChangeReason as R, type UseListboxItemParams as U, type VirtualItem as V, inputChange as a, inputClear as b, imperativeAction as c, triggerContextMenu as d, escapeKey as e, focusOut as f, closePress as g, siblingOpen as h, itemPress as i, triggerHover as j, keyboard as k, listNavigation as l, triggerFocus as m, none as n, outsidePress as o, pointer as p, type ListboxState as q, ListboxStore as r, submenuTrigger as s, triggerPress as t, type ItemContextValue as u, useItemContext as v, useMaybeItemContext as w, ItemContext as x, type UseListboxItemReturn as y, useListboxItem as z };