@workday/canvas-kit-react 7.1.4 → 7.2.0-427-next.2

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

@@ -2,18 +2,46 @@ import React from 'react';
 import { Generic } from '@workday/canvas-kit-react/common';
 import { Item } from './useBaseListModel';
 declare type NavigationInput = Pick<ReturnType<typeof useCursorListModel>, 'state'>;
+/**
+ * The list and grid models accept a `navigation` config. If one is not provided, a default will be
+ * chosen. It is possible to create a custom navigation manager to hand to the model if the default
+ * doesn't work.
+ */
 export interface NavigationManager {
+    /** Get the first item in a collection. This will be called when the `Home` key is pressed for
+     * Lists and `Ctrl+Home` for Grids. */
     getFirst: NavigationRequestor;
+    /** Get the last item in a collection. This will be called when the `End` key is pressed for Lists
+     * and `Ctrl+End` for Grids. */
     getLast: NavigationRequestor;
-    getItem: NavigationRequestor;
+    /** Get an item with the provided `id`. */
+    getItem: (id: string, model: NavigationInput) => Item<Generic>;
+    /** Get the next item after the provided `id`. This will be called when the `Right` arrow key is
+     * pressed for RTL languages and when the `Left` arrow is pressed for LTR languages. */
     getNext: NavigationRequestor;
+    /** **For Grids:** Get the cell in the next row from the provided `id`. This will be called when
+     * the `Down` arrow is pressed.  */
     getNextRow: NavigationRequestor;
+    /** Get the previous item before the provided `id`. This will be called when the `Left` arrow key
+     * is pressed for RTL languages and when the `Right` arrow is pressed for LTR languages. */
     getPrevious: NavigationRequestor;
+    /** **For Grids:** Get the cell in the previous row from the provided `id`. This will be called
+     * when the `Up` arrow is pressed.  */
     getPreviousRow: NavigationRequestor;
+    /** **For Grids:** Get the first item in a row. This will be called when the `Home` key is
+     * pressed. */
     getFirstOfRow: NavigationRequestor;
+    /** **For Grids:** Get the last item in a row. This will be called when the `End` key is
+     * pressed. */
     getLastOfRow: NavigationRequestor;
-    getPreviousPage: NavigationRequestor;
+    /** Get the next "page". A "page" is application specific and usually means next visible screen.
+     * If the viewport is scrollable, it would scroll so that the last item visible is now the first
+     * item visible. This is called when the `PageDown` key is pressed */
     getNextPage: NavigationRequestor;
+    /** Get the next "page". A "page" is application specific and usually means previous visible
+     * screen. If the viewport is scrollable, it would scroll so that the first item visible is now
+     * the last item visible. This is called when the `PageUp` key is pressed */
+    getPreviousPage: NavigationRequestor;
 }
 /**
  * Factory function that does type checking to create navigation managers. Navigation managers
@@ -33,8 +61,10 @@ export interface NavigationManager {
  * ```
  */
 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>;
+/**
+ * Given an id and a model, return an item from the collection
+ */
+export declare type NavigationRequestor = (index: number, model: NavigationInput) => number;
 /**
  * Get the first item in a list regardless of column count
  */
@@ -61,12 +91,18 @@ export declare const getPreviousPage: NavigationRequestor;
  * 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>;
+export declare const getWrappingOffsetItem: (offset: number) => (index: number, { state }: NavigationInput, tries?: number) => number;
+export declare const getOffsetItem: (offset: number) => (index: number, { state }: NavigationInput, tries?: number) => number;
 /**
- * The default navigation manager of lists
+ * The default navigation manager of lists. This navigation manager will wrap around when the edge
+ * is hit. For example, if the user is the the right-most item in a list or right-most item in a
+ * row, the cursor will wrap around to the beginning or the next row.
  */
 export declare const wrappingNavigationManager: NavigationManager;
+/**
+ * The default navigation of grids. This navigation manager will not wrap, but will stop when an
+ * edge is detected. This could be the last item in a list or the last item of a row in a grid.
+ */
 export declare const navigationManager: NavigationManager;
 /**
  * A `CursorModel` extends a `ListModel` and adds a "cursor" to the list. A cursor is a pointer to a
@@ -89,15 +125,18 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
      * (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.
+     * navigation manager will accept `orientation` and directionality to determine mapping.
      *
      * 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;
+    /**
+     * Controls how much a pageUp/pageDown navigation request will jump. If not provided, the size
+     * of the list and number of items rendered will determine this value.
+     */
+    pageSize: number;
     id: string;
     getId: (item: any) => string;
     getTextValue: (item: any) => string;
@@ -107,330 +146,486 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
     shouldVirtualize: boolean;
     items: any[];
 }> & {
-    onRegisterItem?: ((data: {
-        item: any;
-        textValue: string;
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => void) | undefined;
-    onGoTo?: ((data: {
-        id: string;
-    }, prevState: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => void) | undefined;
-    onGoToNext?: ((data: undefined, prevState: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => void) | undefined;
-    onGoToPrevious?: ((data: undefined, prevState: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => void) | undefined;
-    onGoToPreviousRow?: ((data: undefined, prevState: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => void) | undefined;
-    onGoToNextRow?: ((data: undefined, prevState: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => void) | undefined;
-    onGoToFirst?: ((data: undefined, prevState: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => void) | undefined;
-    onGoToLast?: ((data: undefined, prevState: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => void) | undefined;
-    onGoToFirstOfRow?: ((data: undefined, prevState: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => void) | undefined;
-    onGoToLastOfRow?: ((data: undefined, prevState: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => void) | undefined;
-    onGoToNextPage?: ((data: undefined, prevState: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => void) | undefined;
-    onGoToPreviousPage?: ((data: undefined, prevState: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
@@ -444,22 +639,35 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         /**
          * Any positive non-zero value treats the list like a grid with rows and columns
          * @default 0
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
@@ -473,352 +681,521 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         /**
          * Any positive non-zero value treats the list like a grid with rows and columns
          * @default 0
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => void) | undefined;
 } & {
-    shouldRegisterItem?: ((data: {
-        item: any;
-        textValue: string;
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => boolean) | undefined;
-    shouldGoTo?: ((data: {
-        id: string;
-    }, state: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => boolean) | undefined;
-    shouldGoToNext?: ((data: undefined, state: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => boolean) | undefined;
-    shouldGoToPrevious?: ((data: undefined, state: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => boolean) | undefined;
-    shouldGoToPreviousRow?: ((data: undefined, state: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => boolean) | undefined;
-    shouldGoToNextRow?: ((data: undefined, state: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => boolean) | undefined;
-    shouldGoToFirst?: ((data: undefined, state: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => boolean) | undefined;
-    shouldGoToLast?: ((data: undefined, state: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => boolean) | undefined;
-    shouldGoToFirstOfRow?: ((data: undefined, state: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => boolean) | undefined;
-    shouldGoToLastOfRow?: ((data: undefined, state: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => boolean) | undefined;
-    shouldGoToNextPage?: ((data: undefined, state: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
         items: Item<any>[];
     }) => boolean) | undefined;
-    shouldGoToPreviousPage?: ((data: undefined, state: {
+    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
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
@@ -832,22 +1209,35 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         /**
          * Any positive non-zero value treats the list like a grid with rows and columns
          * @default 0
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
@@ -861,22 +1251,35 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         /**
          * Any positive non-zero value treats the list like a grid with rows and columns
          * @default 0
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
@@ -889,36 +1292,41 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         /**
          * Any positive non-zero value treats the list like a grid with rows and columns
          * @default 0
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         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;
@@ -957,6 +1365,10 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         goToLastOfRow(): void;
         goToNextPage(): void;
         goToPreviousPage(): void;
+        registerItem(data: {
+            item: any;
+            textValue: string;
+        }): void;
         unregisterItem(data: {
             id: string;
         }): void;
@@ -966,7 +1378,7 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
     };
     navigation: NavigationManager;
     getId: (item: any) => string;
-}) & import("../../common").ModelExtras<{
+}) & import("@workday/canvas-kit-react/common").ModelExtras<{
     /**
      * Initial cursor position. If not provided, the cursor will point to the first item in the list
      */
@@ -982,15 +1394,18 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
      * (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.
+     * navigation manager will accept `orientation` and directionality to determine mapping.
      *
      * 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;
+    /**
+     * Controls how much a pageUp/pageDown navigation request will jump. If not provided, the size
+     * of the list and number of items rendered will determine this value.
+     */
+    pageSize: number;
     id: string;
     getId: (item: any) => string;
     getTextValue: (item: any) => string;
@@ -1005,35 +1420,40 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
     /**
      * Any positive non-zero value treats the list like a grid with rows and columns
      * @default 0
+     * @private Use useGridModel instead to make a grid instead of a list
      */
     columnCount: number;
+    /**
+     * A React.Ref of the current page size. Either provided as config, or determined at runtime
+     * based on the size of the list container and the number of items fitting within the container.
+     */
+    pageSizeRef: React.MutableRefObject<number>;
+    /**
+     * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+     * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+     * or the `items` change.
+     *
+     * @readonly
+     */
+    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;
-        /**
-         * 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;
+    orientation: "horizontal" | "vertical";
     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;
@@ -1072,6 +1492,10 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
     goToLastOfRow(): void;
     goToNextPage(): void;
     goToPreviousPage(): void;
+    registerItem(data: {
+        item: any;
+        textValue: string;
+    }): void;
     unregisterItem(data: {
         id: string;
     }): void;
@@ -1085,36 +1509,41 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         /**
          * Any positive non-zero value treats the list like a grid with rows and columns
          * @default 0
+         * @private Use useGridModel instead to make a grid instead of a list
          */
         columnCount: number;
+        /**
+         * A React.Ref of the current page size. Either provided as config, or determined at runtime
+         * based on the size of the list container and the number of items fitting within the container.
+         */
+        pageSizeRef: React.MutableRefObject<number>;
+        /**
+         * A readonly [React.Ref](https://react.dev/learn/referencing-values-with-refs) that tracks the
+         * index of the `state.cursorId`. This value is automatically updated when the `state.cursorId`
+         * or the `items` change.
+         *
+         * @readonly
+         */
+        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;
-            /**
-             * 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;
+        orientation: "horizontal" | "vertical";
         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;
@@ -1153,6 +1582,10 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         goToLastOfRow(): void;
         goToNextPage(): void;
         goToPreviousPage(): void;
+        registerItem(data: {
+            item: any;
+            textValue: string;
+        }): void;
         unregisterItem(data: {
             id: string;
         }): void;