@workday/canvas-kit-react 6.8.9 → 6.9.0-next.5

package/dist/commonjs/tabs/lib/useTabsModel.d.ts

@@ -1,90 +1,2407 @@
-import { ToModelConfig } from '@workday/canvas-kit-react/common';
-import { Orientation } from './cursor';
-import { ListEvents, ListState } from './list';
-import { MenuModel, MenuModelConfig } from './menu';
-import { OverflowEvents, OverflowState, BaseOverflowModelConfig, OverflowModel } from './overflow';
-export declare type TabsState<T> = OverflowState<T> & {
-    /** IDREF of the list. Children ids can be derived from this id */
-    id: string;
+import React from 'react';
+export declare const useTabsModel: (<TT_Special_Generic>(config?: (Partial<{
     /**
-     * A list of panels. Uses `ListModel`
-     */
-    panels: T[];
-    /**
-     * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
-     * React state cycle to ensure accurate index tracking as items are registered within the same
-     * state setting phase.
+     * Optional id for the whole `Tabs` group. The `aria-controls` of the `Tab.Item` and `id` of the
+     * `Tab.Panel` will automatically derived from this id. If not provided, a unique id will be
+     * created.
+     * @default useUniqueId()
      */
-    panelIndexRef: ListState<T>['indexRef'];
-    orientation: Orientation;
-    getId: (item: T) => string;
-};
-export declare type TabsEvents<T = unknown> = OverflowEvents<T> & {
+    id: string;
     /**
-     * This event registers panels with state.panels. Called when a panel is mounted.
+     * An initially selected tab. This value must match the `name` of the `Tab.Item` component. If
+     * not provided, the first tab will be selected.
      */
-    registerPanel: ListEvents<T>['registerItem'];
+    initialTab: string;
     /**
-     * This event unregisters panels with state.panels. Called when a panel is unmounted.
+     * The default Tabs sub-components only handle rendering of tabs in a horizontal orientation, but
+     * the sub-components could be replaced to handle vertical orientations.
+     * @default 'horizontal'
      */
-    unregisterPanel: ListEvents<T>['unregisterItem'];
-};
-export interface TabsModel<T = unknown> extends OverflowModel<T> {
-    state: TabsState<T>;
-    events: TabsEvents<T>;
-    menu: MenuModel<T>;
-}
-export declare const tabEventMap: {
-    guards: {
-        shouldSetContainerWidth: "setContainerWidth";
-        shouldSetOverflowTargetWidth: "setOverflowTargetWidth";
-        shouldAddItemWidth: "addItemWidth";
-        shouldRemoveItemWidth: "removeItemWidth";
-        shouldAddHiddenKey: "addHiddenKey";
-        shouldRemoveHiddenKey: "removeHiddenKey";
-        shouldSelect: "select"; /**
+    orientation: import("../../collection/lib/useBaseListModel").Orientation;
+    menuConfig: Partial<{
+        mode: "multiple" | "single";
+        returnFocusRef: React.RefObject<any> | undefined;
+        initialFocusRef: React.RefObject<any> | undefined;
+        id: string;
+        initialVisibility: import("../..").Visibility;
+        initialSelectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        initialUnselectedIds: string[];
+        selection: import("../../collection/lib/useSelectionListModel").SelectionManager;
+        initialCursorId: string;
+        columnCount: number;
+        navigation: import("../../collection/lib/useCursorListModel").NavigationManager;
+        getId: (item: any) => string;
+        getTextValue: (item: any) => string;
+        nonInteractiveIds: string[];
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        defaultItemHeight: number;
+        shouldVirtualize: boolean;
+        items: any[];
+    }>;
+    initialHiddenIds: string[];
+    containerWidth: number;
+    shouldCalculateOverflow: boolean;
+    initialSelectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+    initialUnselectedIds: string[];
+    selection: import("../../collection/lib/useSelectionListModel").SelectionManager;
+    initialCursorId: string;
+    columnCount: number;
+    navigation: import("../../collection/lib/useCursorListModel").NavigationManager;
+    getId: (item: any) => string;
+    getTextValue: (item: any) => string;
+    nonInteractiveIds: string[];
+    defaultItemHeight: number;
+    shouldVirtualize: boolean;
+    items: any[];
+}> & {
+    onRegisterPanel?: ((data: {
+        item: any;
+        textValue: string;
+    }, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onUnregisterPanel?: ((data: {
+        id: string;
+    }, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onSelect?: ((data: {
+        id: string;
+    }, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onSetContainerWidth?: ((data: {
+        width?: number | undefined;
+    }, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onSetOverflowTargetWidth?: ((data: {
+        width: number;
+    }, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onAddItemWidth?: ((data: {
+        id: string;
+        width: number;
+    }, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onRemoveItemWidth?: ((data: {
+        id: string;
+    }, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onAddHiddenKey?: ((data: {
+        id: string;
+    }, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onRemoveHiddenKey?: ((data: {
+        id: string;
+    }, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onSelectAll?: ((data: undefined, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onUnselectAll?: ((data: undefined, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onRegisterItem?: ((data: {
+        item: any;
+        textValue: string;
+    }, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onGoTo?: ((data: {
+        id: string;
+    }, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onGoToNext?: ((data: undefined, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onGoToPrevious?: ((data: undefined, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onGoToPreviousRow?: ((data: undefined, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onGoToNextRow?: ((data: undefined, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onGoToFirst?: ((data: undefined, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onGoToLast?: ((data: undefined, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onGoToFirstOfRow?: ((data: undefined, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onGoToLastOfRow?: ((data: undefined, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onGoToNextPage?: ((data: undefined, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onGoToPreviousPage?: ((data: undefined, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onUnregisterItem?: ((data: {
+        id: string;
+    }, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+    onUpdateItemHeight?: ((data: {
+        value: number;
+    }, prevState: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => void) | undefined;
+} & {
+    shouldRegisterPanel?: ((data: {
+        item: any;
+        textValue: string;
+    }, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldUnregisterPanel?: ((data: {
+        id: string;
+    }, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldSelect?: ((data: {
+        id: string;
+    }, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldSetContainerWidth?: ((data: {
+        width?: number | undefined;
+    }, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldSetOverflowTargetWidth?: ((data: {
+        width: number;
+    }, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldAddItemWidth?: ((data: {
+        id: string;
+        width: number;
+    }, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldRemoveItemWidth?: ((data: {
+        id: string;
+    }, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldAddHiddenKey?: ((data: {
+        id: string;
+    }, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldRemoveHiddenKey?: ((data: {
+        id: string;
+    }, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldSelectAll?: ((data: undefined, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldUnselectAll?: ((data: undefined, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldRegisterItem?: ((data: {
+        item: any;
+        textValue: string;
+    }, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoTo?: ((data: {
+        id: string;
+    }, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToNext?: ((data: undefined, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToPrevious?: ((data: undefined, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToPreviousRow?: ((data: undefined, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToNextRow?: ((data: undefined, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToFirst?: ((data: undefined, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToLast?: ((data: undefined, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToFirstOfRow?: ((data: undefined, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToLastOfRow?: ((data: undefined, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToNextPage?: ((data: undefined, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToPreviousPage?: ((data: undefined, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldUnregisterItem?: ((data: {
+        id: string;
+    }, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+    shouldUpdateItemHeight?: ((data: {
+        value: number;
+    }, state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    }) => boolean) | undefined;
+}) | undefined) => {
+    state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    };
+    events: {
+        /**
+         * This event registers panels with state.panels. Called when a panel is mounted.
+         */
+        registerPanel: (data: {
+            item: any;
+            textValue: string;
+        }) => void;
+        /**
          * This event unregisters panels with state.panels. Called when a panel is unmounted.
          */
-        shouldGoTo: "goTo";
-        shouldRegisterItem: "registerItem";
-        shouldUnregisterItem: "unregisterItem";
-        shouldUpdateItemPosition: "updateItemPosition";
+        unregisterPanel: (data: {
+            id: string;
+        }) => void;
+        select(data: {
+            id: string;
+        }): void;
+        setContainerWidth(data: {
+            width?: number | undefined;
+        }): void;
+        setOverflowTargetWidth(data: {
+            width: number;
+        }): void;
+        addItemWidth(data: {
+            id: string;
+            width: number;
+        }): void;
+        removeItemWidth(data: {
+            id: string;
+        }): void;
+        addHiddenKey(data: {
+            id: string;
+        }): void;
+        removeHiddenKey(data: {
+            id: string;
+        }): void;
+        selectAll(): void;
+        unselectAll(): void;
+        registerItem(data: {
+            item: any;
+            textValue: string;
+        }): void;
+        goTo(data: {
+            id: string;
+        }): void;
+        goToNext(): void;
+        goToPrevious(): void;
+        goToPreviousRow(): void;
+        goToNextRow(): void;
+        goToFirst(): void;
+        goToLast(): void;
+        goToFirstOfRow(): void;
+        goToLastOfRow(): void;
+        goToNextPage(): void;
+        goToPreviousPage(): void;
+        unregisterItem(data: {
+            id: string;
+        }): void;
+        updateItemHeight(data: {
+            value: number;
+        }): void;
     };
-    callbacks: {
-        onSetContainerWidth: "setContainerWidth";
-        onSetOverflowTargetWidth: "setOverflowTargetWidth";
-        onAddItemWidth: "addItemWidth";
-        onRemoveItemWidth: "removeItemWidth";
-        onAddHiddenKey: "addHiddenKey";
-        onRemoveHiddenKey: "removeHiddenKey";
-        onSelect: "select";
-        onGoTo: "goTo";
-        onRegisterItem: "registerItem";
-        onUnregisterItem: "unregisterItem";
-        onUpdateItemPosition: "updateItemPosition";
+    menu: {
+        state: {
+            stackRef: React.RefObject<HTMLDivElement>;
+            targetRef: React.RefObject<HTMLButtonElement>;
+            initialFocusRef: React.RefObject<any> | undefined;
+            returnFocusRef: React.RefObject<any> | undefined;
+            placement: import("@popperjs/core").Placement;
+            id: string;
+            visibility: import("../..").Visibility;
+            selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+            unselectedIds: string[];
+            cursorId: string;
+            columnCount: number;
+            UNSTABLE_virtual: {
+                virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+                totalSize: number;
+                scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+                scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+                measure: () => void;
+            };
+            UNSTABLE_defaultItemHeight: number;
+            containerRef: React.RefObject<HTMLDivElement>;
+            orientation: import("../../collection/lib/useBaseListModel").Orientation;
+            indexRef: React.MutableRefObject<number>;
+            nonInteractiveIds: string[];
+            isVirtualized: boolean;
+            items: import("../../collection").Item<any>[];
+            mode: "multiple" | "single";
+        };
+        events: {
+            updatePlacement(data: {
+                placement: import("@popperjs/core").Placement;
+            }): void;
+            show(event?: Event | React.SyntheticEvent<Element, Event> | undefined): void;
+            hide(event?: Event | React.SyntheticEvent<Element, Event> | undefined): void;
+            select(data: {
+                id: string;
+            }): void;
+            selectAll(): void;
+            unselectAll(): void;
+            registerItem(data: {
+                item: any;
+                textValue: string;
+            }): void;
+            goTo(data: {
+                id: string;
+            }): void;
+            goToNext(): void;
+            goToPrevious(): void;
+            goToPreviousRow(): void;
+            goToNextRow(): void;
+            goToFirst(): void;
+            goToLast(): void;
+            goToFirstOfRow(): void;
+            goToLastOfRow(): void;
+            goToNextPage(): void;
+            goToPreviousPage(): void;
+            unregisterItem(data: {
+                id: string;
+            }): void;
+            updateItemHeight(data: {
+                value: number;
+            }): void;
+        };
+        selection: import("../../collection/lib/useSelectionListModel").SelectionManager;
+        navigation: import("../../collection/lib/useCursorListModel").NavigationManager;
+        getId: (item: any) => string;
     };
-};
-export declare type BaseTabsModelConfig<T> = Omit<BaseOverflowModelConfig<T>, 'orientation'> & {
+    selection: import("../../collection/lib/useSelectionListModel").SelectionManager;
+    navigation: import("../../collection/lib/useCursorListModel").NavigationManager;
+    getId: (item: any) => string;
+}) & import("../../common").ModelExtras<{
     /**
      * Optional id for the whole `Tabs` group. The `aria-controls` of the `Tab.Item` and `id` of the
      * `Tab.Panel` will automatically derived from this id. If not provided, a unique id will be
      * created.
      * @default useUniqueId()
      */
-    id?: string;
+    id: string;
     /**
      * An initially selected tab. This value must match the `name` of the `Tab.Item` component. If
      * not provided, the first tab will be selected.
      */
-    initialTab?: string;
+    initialTab: string;
     /**
      * The default Tabs sub-components only handle rendering of tabs in a horizontal orientation, but
      * the sub-components could be replaced to handle vertical orientations.
      * @default 'horizontal'
      */
-    orientation?: Orientation;
-    menuConfig?: MenuModelConfig<T>;
-};
-export declare type TabsModelConfig<T> = BaseTabsModelConfig<T> & Partial<ToModelConfig<TabsState<T>, TabsEvents<T>, typeof tabEventMap>>;
-export declare const useTabsModel: <T extends unknown>(config?: TabsModelConfig<T>) => TabsModel<T>;
+    orientation: import("../../collection/lib/useBaseListModel").Orientation;
+    menuConfig: Partial<{
+        mode: "multiple" | "single";
+        returnFocusRef: React.RefObject<any> | undefined;
+        initialFocusRef: React.RefObject<any> | undefined;
+        id: string;
+        initialVisibility: import("../..").Visibility;
+        initialSelectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        initialUnselectedIds: string[];
+        selection: import("../../collection/lib/useSelectionListModel").SelectionManager;
+        initialCursorId: string;
+        columnCount: number;
+        navigation: import("../../collection/lib/useCursorListModel").NavigationManager;
+        getId: (item: any) => string;
+        getTextValue: (item: any) => string;
+        nonInteractiveIds: string[];
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        defaultItemHeight: number;
+        shouldVirtualize: boolean;
+        items: any[];
+    }>;
+    initialHiddenIds: string[];
+    containerWidth: number;
+    shouldCalculateOverflow: boolean;
+    initialSelectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+    initialUnselectedIds: string[];
+    selection: import("../../collection/lib/useSelectionListModel").SelectionManager;
+    initialCursorId: string;
+    columnCount: number;
+    navigation: import("../../collection/lib/useCursorListModel").NavigationManager;
+    getId: (item: any) => string;
+    getTextValue: (item: any) => string;
+    nonInteractiveIds: string[];
+    defaultItemHeight: number;
+    shouldVirtualize: boolean;
+    items: any[];
+}, {}, {
+    getId: (item: any) => string;
+    orientation: import("../../collection/lib/useBaseListModel").Orientation;
+    /**
+     * A list of panels. Uses `ListModel`
+     */
+    panels: import("../../collection").Item<any>[];
+    /**
+     * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+     * React state cycle to ensure accurate index tracking as items are registered within the same
+     * state setting phase.
+     */
+    panelIndexRef: React.MutableRefObject<number>;
+    hiddenIds: string[];
+    itemWidthCache: Record<string, number>;
+    containerWidth: number;
+    overflowTargetWidth: number;
+    selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+    unselectedIds: string[];
+    cursorId: string;
+    columnCount: number;
+    UNSTABLE_virtual: {
+        virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+        totalSize: number;
+        scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+        scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+        measure: () => void;
+    };
+    UNSTABLE_defaultItemHeight: number;
+    containerRef: React.RefObject<HTMLDivElement>;
+    id: string;
+    indexRef: React.MutableRefObject<number>;
+    nonInteractiveIds: string[];
+    isVirtualized: boolean;
+    items: import("../../collection").Item<any>[];
+}, {
+    /**
+     * This event registers panels with state.panels. Called when a panel is mounted.
+     */
+    registerPanel: (data: {
+        item: any;
+        textValue: string;
+    }) => void;
+    /**
+     * This event unregisters panels with state.panels. Called when a panel is unmounted.
+     */
+    unregisterPanel: (data: {
+        id: string;
+    }) => void;
+    select(data: {
+        id: string;
+    }): void;
+    setContainerWidth(data: {
+        width?: number | undefined;
+    }): void;
+    setOverflowTargetWidth(data: {
+        width: number;
+    }): void;
+    addItemWidth(data: {
+        id: string;
+        width: number;
+    }): void;
+    removeItemWidth(data: {
+        id: string;
+    }): void;
+    addHiddenKey(data: {
+        id: string;
+    }): void;
+    removeHiddenKey(data: {
+        id: string;
+    }): void;
+    selectAll(): void;
+    unselectAll(): void;
+    registerItem(data: {
+        item: any;
+        textValue: string;
+    }): void;
+    goTo(data: {
+        id: string;
+    }): void;
+    goToNext(): void;
+    goToPrevious(): void;
+    goToPreviousRow(): void;
+    goToNextRow(): void;
+    goToFirst(): void;
+    goToLast(): void;
+    goToFirstOfRow(): void;
+    goToLastOfRow(): void;
+    goToNextPage(): void;
+    goToPreviousPage(): void;
+    unregisterItem(data: {
+        id: string;
+    }): void;
+    updateItemHeight(data: {
+        value: number;
+    }): void;
+}, {
+    state: {
+        getId: (item: any) => string;
+        orientation: import("../../collection/lib/useBaseListModel").Orientation;
+        /**
+         * A list of panels. Uses `ListModel`
+         */
+        panels: import("../../collection").Item<any>[];
+        /**
+         * A React.Ref of the current item index. A ref is used to allow for updating outside the normal
+         * React state cycle to ensure accurate index tracking as items are registered within the same
+         * state setting phase.
+         */
+        panelIndexRef: React.MutableRefObject<number>;
+        hiddenIds: string[];
+        itemWidthCache: Record<string, number>;
+        containerWidth: number;
+        overflowTargetWidth: number;
+        selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+        unselectedIds: string[];
+        cursorId: string;
+        columnCount: number;
+        UNSTABLE_virtual: {
+            virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("../../collection").Item<any>[];
+    };
+    events: {
+        /**
+         * This event registers panels with state.panels. Called when a panel is mounted.
+         */
+        registerPanel: (data: {
+            item: any;
+            textValue: string;
+        }) => void;
+        /**
+         * This event unregisters panels with state.panels. Called when a panel is unmounted.
+         */
+        unregisterPanel: (data: {
+            id: string;
+        }) => void;
+        select(data: {
+            id: string;
+        }): void;
+        setContainerWidth(data: {
+            width?: number | undefined;
+        }): void;
+        setOverflowTargetWidth(data: {
+            width: number;
+        }): void;
+        addItemWidth(data: {
+            id: string;
+            width: number;
+        }): void;
+        removeItemWidth(data: {
+            id: string;
+        }): void;
+        addHiddenKey(data: {
+            id: string;
+        }): void;
+        removeHiddenKey(data: {
+            id: string;
+        }): void;
+        selectAll(): void;
+        unselectAll(): void;
+        registerItem(data: {
+            item: any;
+            textValue: string;
+        }): void;
+        goTo(data: {
+            id: string;
+        }): void;
+        goToNext(): void;
+        goToPrevious(): void;
+        goToPreviousRow(): void;
+        goToNextRow(): void;
+        goToFirst(): void;
+        goToLast(): void;
+        goToFirstOfRow(): void;
+        goToLastOfRow(): void;
+        goToNextPage(): void;
+        goToPreviousPage(): void;
+        unregisterItem(data: {
+            id: string;
+        }): void;
+        updateItemHeight(data: {
+            value: number;
+        }): void;
+    };
+    menu: {
+        state: {
+            stackRef: React.RefObject<HTMLDivElement>;
+            targetRef: React.RefObject<HTMLButtonElement>;
+            initialFocusRef: React.RefObject<any> | undefined;
+            returnFocusRef: React.RefObject<any> | undefined;
+            placement: import("@popperjs/core").Placement;
+            id: string;
+            visibility: import("../..").Visibility;
+            selectedIds: import("../../collection/lib/useSelectionListModel").SelectedIds;
+            unselectedIds: string[];
+            cursorId: string;
+            columnCount: number;
+            UNSTABLE_virtual: {
+                virtualItems: import("../../collection/lib/react-virtual").VirtualItem[];
+                totalSize: number;
+                scrollToOffset: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToOffsetOptions | undefined) => void;
+                scrollToIndex: (index: number, options?: import("../../collection/lib/react-virtual").ScrollToIndexOptions | undefined) => void;
+                measure: () => void;
+            };
+            UNSTABLE_defaultItemHeight: number;
+            containerRef: React.RefObject<HTMLDivElement>;
+            orientation: import("../../collection/lib/useBaseListModel").Orientation;
+            indexRef: React.MutableRefObject<number>;
+            nonInteractiveIds: string[];
+            isVirtualized: boolean;
+            items: import("../../collection").Item<any>[];
+            mode: "multiple" | "single";
+        };
+        events: {
+            updatePlacement(data: {
+                placement: import("@popperjs/core").Placement;
+            }): void;
+            show(event?: Event | React.SyntheticEvent<Element, Event> | undefined): void;
+            hide(event?: Event | React.SyntheticEvent<Element, Event> | undefined): void;
+            select(data: {
+                id: string;
+            }): void;
+            selectAll(): void;
+            unselectAll(): void;
+            registerItem(data: {
+                item: any;
+                textValue: string;
+            }): void;
+            goTo(data: {
+                id: string;
+            }): void;
+            goToNext(): void;
+            goToPrevious(): void;
+            goToPreviousRow(): void;
+            goToNextRow(): void;
+            goToFirst(): void;
+            goToLast(): void;
+            goToFirstOfRow(): void;
+            goToLastOfRow(): void;
+            goToNextPage(): void;
+            goToPreviousPage(): void;
+            unregisterItem(data: {
+                id: string;
+            }): void;
+            updateItemHeight(data: {
+                value: number;
+            }): void;
+        };
+        selection: import("../../collection/lib/useSelectionListModel").SelectionManager;
+        navigation: import("../../collection/lib/useCursorListModel").NavigationManager;
+        getId: (item: any) => string;
+    };
+    selection: import("../../collection/lib/useSelectionListModel").SelectionManager;
+    navigation: import("../../collection/lib/useCursorListModel").NavigationManager;
+    getId: (item: any) => string;
+}>;
 //# sourceMappingURL=useTabsModel.d.ts.map