@workday/canvas-kit-react/dist/commonjs/collection/lib/useOverflowListModel.d.ts

The parent module that contains all Workday Canvas Kit React components

import React from 'react';
import { Item } from './useBaseListModel';
export declare function getHiddenIds(containerSize: number, containerGap: number, overflowTargetSize: number, itemSizeCache: Record<string, number>, selectedIds: string[] | 'all', items: Item<any>[]): string[];
export declare const useOverflowListModel: (<TT_Special_Generic>(config?: (Partial<{
    initialHiddenIds: string[];
    containerWidth: number;
    /**
     * Determines if overflow should actually occur. For example, touch devices are better at
     * side-scrolling than mouse devices. In these cases, it makes sense to disable overflowing.
     * @default true
     */ shouldCalculateOverflow: boolean;
    initialSelectedIds: import("./useSelectionListModel").SelectedIds;
    initialUnselectedIds: string[];
    selection: import("./useSelectionListModel").SelectionManager;
    initialCursorId: string;
    columnCount: number;
    navigation: import("./useCursorListModel").NavigationManager;
    pageSize: number;
    id: string;
    getId: (item: any) => string;
    getTextValue: (item: any) => string;
    nonInteractiveIds: string[];
    orientation: import("./useBaseListModel").Orientation;
    defaultItemHeight: number;
    shouldVirtualize: boolean;
    items: any[];
}> & {
    onSelect?: ((data: {
        id: string;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onSetContainerSize?: ((data: {
        width?: number | undefined;
        height?: number | undefined;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onSetContainerWidth?: ((data: {
        width?: number | undefined;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onSetContainerGap?: ((data: {
        size: number;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onSetOverflowTargetSize?: ((data: {
        width: number;
        height: number;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onSetOverflowTargetWidth?: ((data: {
        width: number;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onAddItemWidth?: ((data: {
        id: string;
        width: number;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onAddItemSize?: ((data: {
        id: string;
        width: number;
        height: number;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onRemoveItemSize?: ((data: {
        id: string;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onRemoveItemWidth?: ((data: {
        id: string;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onAddHiddenKey?: ((data: {
        id: string;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onRemoveHiddenKey?: ((data: {
        id: string;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onSelectAll?: ((data: undefined, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onUnselectAll?: ((data: undefined, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onSetSelectedIds?: ((data: string[] | "all", prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onRemove?: ((data: {
        id: string;
        nextId?: string | undefined;
        event?: Event | React.SyntheticEvent<Element, Event> | undefined;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onGoTo?: ((data: {
        id: string;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onGoToNext?: ((data: undefined, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onGoToPrevious?: ((data: undefined, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onGoToPreviousRow?: ((data: undefined, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onGoToNextRow?: ((data: undefined, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onGoToFirst?: ((data: undefined, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onGoToLast?: ((data: undefined, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onGoToFirstOfRow?: ((data: undefined, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onGoToLastOfRow?: ((data: undefined, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onGoToNextPage?: ((data: undefined, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onGoToPreviousPage?: ((data: undefined, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onRegisterItem?: ((data: {
        id: string;
        textValue: string;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onUnregisterItem?: ((data: {
        id: string;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
    onUpdateItemHeight?: ((data: {
        value: number;
    }, prevState: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => void) | undefined;
} & {
    shouldSelect?: ((data: {
        id: string;
    }, state: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => boolean) | undefined;
    shouldSetContainerSize?: ((data: {
        width?: number | undefined;
        height?: number | undefined;
    }, state: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
            measure: () => void;
        };
        UNSTABLE_defaultItemHeight: number;
        containerRef: React.RefObject<HTMLDivElement>;
        id: string;
        orientation: "horizontal" | "vertical";
        indexRef: React.MutableRefObject<number>;
        nonInteractiveIds: string[];
        isVirtualized: boolean;
        items: Item<any>[];
    }) => boolean) | undefined;
    shouldSetContainerWidth?: ((data: {
        width?: number | undefined;
    }, state: {
        hiddenIds: string[];
        itemSizeCache: Record<string, number>;
        /**
         * @deprecated Use `itemSizeCache` instead
         */
        itemWidthCache: Record<string, number>;
        containerSize: number;
        /**
         * @deprecated Use `containerSize` instead
         */
        containerWidth: number;
        containerGap: number;
        overflowTargetWidth: number;
        selectedIds: string[] | "all";
        unselectedIds: string[];
        cursorId: string;
        columnCount: number;
        pageSizeRef: React.MutableRefObject<number>;
        cursorIndexRef: {
            readonly current: number;
        };
        UNSTABLE_virtual: {
            virtualItems: import("./react-virtual").VirtualItem[];
            totalSize: number;
            scrollToOffset: (inde