@workday/canvas-kit-react 6.8.8 → 6.9.0-next.4

package/dist/commonjs/collection/lib/useCursorListModel.d.ts

@@ -0,0 +1,1167 @@
+import React from 'react';
+import { Generic } from '@workday/canvas-kit-react/common';
+import { Item } from './useBaseListModel';
+declare type NavigationInput = Pick<ReturnType<typeof useCursorListModel>, 'state'>;
+export interface NavigationManager {
+    getFirst: NavigationRequestor;
+    getLast: NavigationRequestor;
+    getItem: NavigationRequestor;
+    getNext: NavigationRequestor;
+    getNextRow: NavigationRequestor;
+    getPrevious: NavigationRequestor;
+    getPreviousRow: NavigationRequestor;
+    getFirstOfRow: NavigationRequestor;
+    getLastOfRow: NavigationRequestor;
+    getPreviousPage: NavigationRequestor;
+    getNextPage: NavigationRequestor;
+}
+/**
+ * Factory function that does type checking to create navigation managers. Navigation managers
+ * are expected to handle all methods of a grid. If your use-case isn't meant to handle a grid,
+ * pick one of the existing navigation managers and override the methods you wish to implement.
+ *
+ * For example,
+ * ```tsx
+ * import {createNavigationManager, wrappingNavigationManager} from '@workday/canvas-kit-react/collection'
+ *
+ * const navigationManager = createNavigationManager({
+ *   ...wrappingNavigationManager,
+ *   getNext(id, {state}) {
+ *     //
+ *   }
+ * })
+ * ```
+ */
+export declare const createNavigationManager: (manager: NavigationManager) => NavigationManager;
+/** Function type to make it easier to define navigation functions */
+export declare type NavigationRequestor = (id: string, { state }: NavigationInput) => Item<Generic>;
+/**
+ * Get the first item in a list regardless of column count
+ */
+export declare const getFirst: NavigationRequestor;
+/**
+ * Get the last item in a list regardless of column count
+ */
+export declare const getLast: NavigationRequestor;
+/**
+ * Get the first item in a row. If column count is 0, it will return the results of `getFirst`
+ */
+export declare const getFirstOfRow: NavigationRequestor;
+/**
+ * get the last item in a row - if column count is 0, it will return the results of `getLast`
+ */
+export declare const getLastOfRow: NavigationRequestor;
+/**
+ * get the item in the previous page. This can be author defined. By default it will return the
+ * first item for a list, and the first item in the same column for a grid.
+ */
+export declare const getPreviousPage: NavigationRequestor;
+/**
+ * get the item in the next page. This can be author defined. By default, it will return the last
+ * item for a list, and the last item in the same column for a grid.
+ */
+export declare const getNextPage: NavigationRequestor;
+export declare const getWrappingOffsetItem: (offset: number) => (id: string, { state }: NavigationInput, tries?: number) => Item<Generic>;
+export declare const getOffsetItem: (offset: number) => (id: string, { state }: NavigationInput, tries?: number) => Item<Generic>;
+/**
+ * The default navigation manager of lists
+ */
+export declare const wrappingNavigationManager: NavigationManager;
+export declare const navigationManager: NavigationManager;
+/**
+ * A `CursorModel` extends a `ListModel` and adds a "cursor" to the list. A cursor is a pointer to a
+ * current position in the list. The most common use-case is keeping track of which item currently
+ * has focus within the list. Many w3c list role types specify a single tab stop within the list.
+ */
+export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial<{
+    /**
+     * Initial cursor position. If not provided, the cursor will point to the first item in the list
+     */
+    initialCursorId: string;
+    /**
+     * If this is set it will cause a wrapping of a list that will turn it into a grid
+     * @default 0
+     */
+    columnCount: number;
+    /**
+     * Controls the state changes when the user sends navigation events to the model. For example,
+     * when the user hits the "right" arrow, a behavior hook will determine directionality
+     * (left-to-right or right-to-left) and call the correct navigation method. In our example, a
+     * left-to-right language would send a `getNext`. The navigation manager may return the next item
+     * in the list. Different managers can be created for slightly different use cases. The default
+     * navigation manager will accept `orientation` and directionality to determine mapping. If
+     * `columnCount` is non-zero, it will use a grid mode where `orientation` is ignored and only
+     * directionality matters.
+     *
+     * An example override might be a tab list with an overflow menu that is meant to be transparent
+     * to screen reader users. This would require the overflow menu to accept both up/down keys as
+     * well as left/right keys to give a more consistent experience to all users.
+     */
+    navigation: NavigationManager;
+    id: string;
+    getId: (item: any) => string;
+    getTextValue: (item: any) => string;
+    nonInteractiveIds: string[];
+    orientation: import("./useBaseListModel").Orientation;
+    defaultItemHeight: number;
+    shouldVirtualize: boolean;
+    items: any[];
+}> & {
+    onRegisterItem?: ((data: {
+        item: any;
+        textValue: string;
+    }, prevState: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => void) | undefined;
+    onGoTo?: ((data: {
+        id: string;
+    }, prevState: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => void) | undefined;
+    onGoToNext?: ((data: undefined, prevState: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => void) | undefined;
+    onGoToPrevious?: ((data: undefined, prevState: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => void) | undefined;
+    onGoToPreviousRow?: ((data: undefined, prevState: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => void) | undefined;
+    onGoToNextRow?: ((data: undefined, prevState: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => void) | undefined;
+    onGoToFirst?: ((data: undefined, prevState: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => void) | undefined;
+    onGoToLast?: ((data: undefined, prevState: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => void) | undefined;
+    onGoToFirstOfRow?: ((data: undefined, prevState: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => void) | undefined;
+    onGoToLastOfRow?: ((data: undefined, prevState: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => void) | undefined;
+    onGoToNextPage?: ((data: undefined, prevState: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => void) | undefined;
+    onGoToPreviousPage?: ((data: undefined, prevState: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => void) | undefined;
+    onUnregisterItem?: ((data: {
+        id: string;
+    }, prevState: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => void) | undefined;
+    onUpdateItemHeight?: ((data: {
+        value: number;
+    }, prevState: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => void) | undefined;
+} & {
+    shouldRegisterItem?: ((data: {
+        item: any;
+        textValue: string;
+    }, state: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoTo?: ((data: {
+        id: string;
+    }, state: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToNext?: ((data: undefined, state: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToPrevious?: ((data: undefined, state: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToPreviousRow?: ((data: undefined, state: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToNextRow?: ((data: undefined, state: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToFirst?: ((data: undefined, state: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToLast?: ((data: undefined, state: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToFirstOfRow?: ((data: undefined, state: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToLastOfRow?: ((data: undefined, state: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToNextPage?: ((data: undefined, state: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => boolean) | undefined;
+    shouldGoToPreviousPage?: ((data: undefined, state: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => boolean) | undefined;
+    shouldUnregisterItem?: ((data: {
+        id: string;
+    }, state: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => boolean) | undefined;
+    shouldUpdateItemHeight?: ((data: {
+        value: number;
+    }, state: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    }) => boolean) | undefined;
+}) | undefined) => {
+    state: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    };
+    events: {
+        /**
+         * Register an item to the list. Takes in an identifier, a React.Ref and an optional index. This
+         * should be called on component mount
+         */
+        registerItem(data: {
+            item: any;
+            textValue: string;
+        }): void;
+        /** Directly sets the cursor to the list item by its identifier. */
+        goTo(data: {
+            id: string;
+        }): void;
+        /**
+         * Set the cursor to the "next" item in the list. This event delegates to the `getNext` method of
+         * the navigation manager. For a list, the default navigation manager will wrap if cursor is
+         * currently on the last item. For a grid, the default navigation manager will stay on the last
+         * item in a row.
+         */
+        goToNext(): void;
+        /**
+         * Set the cursor to the "previous" item in the list. If the beginning of the list is detected,
+         * it will wrap to the last item
+         */
+        goToPrevious(): void;
+        /**
+         * Previous item perpendicular to the orientation of a list, or the previous row in a grid. For
+         * example, if a list is horizontal, the previous row would describe an up direction. This could
+         * be ignored by the navigation manager, or return the same result as `previous()`. In a grid,
+         * this would be the previous row (current position - column count).
+         */
+        goToPreviousRow(): void;
+        /**
+         * Next item perpendicular to the orientation of a list, or the next row in a grid. For example,
+         * if a list is horizontal, the next row would describe a down direction. This could be ignored by
+         * the navigation manager, or return the same result as `next()`. In a grid, this would be the
+         * next row (current position + column count).
+         */
+        goToNextRow(): void;
+        /** Set the cursor to the first item in the list */
+        goToFirst(): void;
+        /** Set the cursor to the last item in the list */
+        goToLast(): void;
+        goToFirstOfRow(): void;
+        goToLastOfRow(): void;
+        goToNextPage(): void;
+        goToPreviousPage(): void;
+        unregisterItem(data: {
+            id: string;
+        }): void;
+        updateItemHeight(data: {
+            value: number;
+        }): void;
+    };
+    navigation: NavigationManager;
+    getId: (item: any) => string;
+}) & import("../../common").ModelExtras<{
+    /**
+     * Initial cursor position. If not provided, the cursor will point to the first item in the list
+     */
+    initialCursorId: string;
+    /**
+     * If this is set it will cause a wrapping of a list that will turn it into a grid
+     * @default 0
+     */
+    columnCount: number;
+    /**
+     * Controls the state changes when the user sends navigation events to the model. For example,
+     * when the user hits the "right" arrow, a behavior hook will determine directionality
+     * (left-to-right or right-to-left) and call the correct navigation method. In our example, a
+     * left-to-right language would send a `getNext`. The navigation manager may return the next item
+     * in the list. Different managers can be created for slightly different use cases. The default
+     * navigation manager will accept `orientation` and directionality to determine mapping. If
+     * `columnCount` is non-zero, it will use a grid mode where `orientation` is ignored and only
+     * directionality matters.
+     *
+     * An example override might be a tab list with an overflow menu that is meant to be transparent
+     * to screen reader users. This would require the overflow menu to accept both up/down keys as
+     * well as left/right keys to give a more consistent experience to all users.
+     */
+    navigation: NavigationManager;
+    id: string;
+    getId: (item: any) => string;
+    getTextValue: (item: any) => string;
+    nonInteractiveIds: string[];
+    orientation: import("./useBaseListModel").Orientation;
+    defaultItemHeight: number;
+    shouldVirtualize: boolean;
+    items: any[];
+}, {}, {
+    /** The id of the list item the cursor is pointing to */
+    cursorId: string;
+    /**
+     * Any positive non-zero value treats the list like a grid with rows and columns
+     * @default 0
+     */
+    columnCount: 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;
+        /**
+         * Get the last item in a list regardless of column count
+         */
+        measure: () => void;
+    };
+    UNSTABLE_defaultItemHeight: number;
+    containerRef: React.RefObject<HTMLDivElement>;
+    id: string;
+    orientation: import("./useBaseListModel").Orientation;
+    indexRef: React.MutableRefObject<number>;
+    nonInteractiveIds: string[];
+    isVirtualized: boolean;
+    items: Item<any>[];
+}, {
+    /**
+     * Register an item to the list. Takes in an identifier, a React.Ref and an optional index. This
+     * should be called on component mount
+     */
+    registerItem(data: {
+        item: any;
+        textValue: string;
+    }): void;
+    /** Directly sets the cursor to the list item by its identifier. */
+    goTo(data: {
+        id: string;
+    }): void;
+    /**
+     * Set the cursor to the "next" item in the list. This event delegates to the `getNext` method of
+     * the navigation manager. For a list, the default navigation manager will wrap if cursor is
+     * currently on the last item. For a grid, the default navigation manager will stay on the last
+     * item in a row.
+     */
+    goToNext(): void;
+    /**
+     * Set the cursor to the "previous" item in the list. If the beginning of the list is detected,
+     * it will wrap to the last item
+     */
+    goToPrevious(): void;
+    /**
+     * Previous item perpendicular to the orientation of a list, or the previous row in a grid. For
+     * example, if a list is horizontal, the previous row would describe an up direction. This could
+     * be ignored by the navigation manager, or return the same result as `previous()`. In a grid,
+     * this would be the previous row (current position - column count).
+     */
+    goToPreviousRow(): void;
+    /**
+     * Next item perpendicular to the orientation of a list, or the next row in a grid. For example,
+     * if a list is horizontal, the next row would describe a down direction. This could be ignored by
+     * the navigation manager, or return the same result as `next()`. In a grid, this would be the
+     * next row (current position + column count).
+     */
+    goToNextRow(): void;
+    /** Set the cursor to the first item in the list */
+    goToFirst(): void;
+    /** Set the cursor to the last item in the list */
+    goToLast(): void;
+    goToFirstOfRow(): void;
+    goToLastOfRow(): void;
+    goToNextPage(): void;
+    goToPreviousPage(): void;
+    unregisterItem(data: {
+        id: string;
+    }): void;
+    updateItemHeight(data: {
+        value: number;
+    }): void;
+}, {
+    state: {
+        /** The id of the list item the cursor is pointing to */
+        cursorId: string;
+        /**
+         * Any positive non-zero value treats the list like a grid with rows and columns
+         * @default 0
+         */
+        columnCount: 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;
+            /**
+             * Get the last item in a list regardless of column count
+             */
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: import("./useBaseListModel").Orientation;
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: Item<any>[];
+    };
+    events: {
+        /**
+         * Register an item to the list. Takes in an identifier, a React.Ref and an optional index. This
+         * should be called on component mount
+         */
+        registerItem(data: {
+            item: any;
+            textValue: string;
+        }): void;
+        /** Directly sets the cursor to the list item by its identifier. */
+        goTo(data: {
+            id: string;
+        }): void;
+        /**
+         * Set the cursor to the "next" item in the list. This event delegates to the `getNext` method of
+         * the navigation manager. For a list, the default navigation manager will wrap if cursor is
+         * currently on the last item. For a grid, the default navigation manager will stay on the last
+         * item in a row.
+         */
+        goToNext(): void;
+        /**
+         * Set the cursor to the "previous" item in the list. If the beginning of the list is detected,
+         * it will wrap to the last item
+         */
+        goToPrevious(): void;
+        /**
+         * Previous item perpendicular to the orientation of a list, or the previous row in a grid. For
+         * example, if a list is horizontal, the previous row would describe an up direction. This could
+         * be ignored by the navigation manager, or return the same result as `previous()`. In a grid,
+         * this would be the previous row (current position - column count).
+         */
+        goToPreviousRow(): void;
+        /**
+         * Next item perpendicular to the orientation of a list, or the next row in a grid. For example,
+         * if a list is horizontal, the next row would describe a down direction. This could be ignored by
+         * the navigation manager, or return the same result as `next()`. In a grid, this would be the
+         * next row (current position + column count).
+         */
+        goToNextRow(): void;
+        /** Set the cursor to the first item in the list */
+        goToFirst(): void;
+        /** Set the cursor to the last item in the list */
+        goToLast(): void;
+        goToFirstOfRow(): void;
+        goToLastOfRow(): void;
+        goToNextPage(): void;
+        goToPreviousPage(): void;
+        unregisterItem(data: {
+            id: string;
+        }): void;
+        updateItemHeight(data: {
+            value: number;
+        }): void;
+    };
+    navigation: NavigationManager;
+    getId: (item: any) => string;
+}>;
+export {};
+//# sourceMappingURL=useCursorListModel.d.ts.map