@workday/canvas-kit-react 8.0.0-alpha.253-next.22 → 8.0.0-alpha.428-next.2

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

@@ -2,6 +2,11 @@ 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. */
@@ -10,7 +15,7 @@ export interface NavigationManager {
      * and `Ctrl+End` for Grids. */
     getLast: NavigationRequestor;
     /** Get an item with the provided `id`. */
-    getItem: NavigationRequestor;
+    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;
@@ -56,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
  */
@@ -84,8 +91,8 @@ 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. 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
@@ -125,6 +132,11 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
      * 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;
@@ -134,9 +146,8 @@ 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;
@@ -146,6 +157,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -156,15 +182,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -173,6 +197,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -183,13 +222,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -198,6 +237,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -208,13 +262,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -223,6 +277,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -233,13 +302,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -248,6 +317,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -258,13 +342,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -273,6 +357,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -283,13 +382,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -298,6 +397,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -308,13 +422,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -323,6 +437,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -333,13 +462,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -348,6 +477,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -358,13 +502,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -373,6 +517,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -383,13 +542,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -398,6 +557,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -408,13 +582,16 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -423,6 +600,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -433,7 +625,7 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         UNSTABLE_defaultItemHeight: number;
         containerRef: React.RefObject<HTMLDivElement>;
         id: string;
-        orientation: import("./useBaseListModel").Orientation;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
@@ -450,6 +642,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -460,7 +667,7 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         UNSTABLE_defaultItemHeight: number;
         containerRef: React.RefObject<HTMLDivElement>;
         id: string;
-        orientation: import("./useBaseListModel").Orientation;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
@@ -477,6 +684,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -487,16 +709,15 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
@@ -506,6 +727,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -516,15 +752,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -533,6 +767,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -543,13 +792,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -558,6 +807,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -568,13 +832,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -583,6 +847,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -593,13 +872,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -608,6 +887,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -618,13 +912,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -633,6 +927,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -643,13 +952,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -658,6 +967,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -668,13 +992,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -683,6 +1007,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -693,13 +1032,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -708,6 +1047,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -718,13 +1072,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -733,6 +1087,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -743,13 +1112,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -758,6 +1127,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -768,13 +1152,16 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
         /**
@@ -783,6 +1170,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -793,7 +1195,7 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         UNSTABLE_defaultItemHeight: number;
         containerRef: React.RefObject<HTMLDivElement>;
         id: string;
-        orientation: import("./useBaseListModel").Orientation;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
@@ -810,6 +1212,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -820,7 +1237,7 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         UNSTABLE_defaultItemHeight: number;
         containerRef: React.RefObject<HTMLDivElement>;
         id: string;
-        orientation: import("./useBaseListModel").Orientation;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
@@ -837,6 +1254,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -847,7 +1279,7 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         UNSTABLE_defaultItemHeight: number;
         containerRef: React.RefObject<HTMLDivElement>;
         id: string;
-        orientation: import("./useBaseListModel").Orientation;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
@@ -863,6 +1295,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -873,21 +1320,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
@@ -926,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;
@@ -935,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
      */
@@ -958,6 +1401,11 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
      * 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;
@@ -975,6 +1423,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
      * @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;
@@ -985,20 +1448,12 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
     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;
@@ -1037,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;
@@ -1053,6 +1512,21 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
          * @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;
@@ -1063,21 +1537,13 @@ export declare const useCursorListModel: (<TT_Special_Generic>(config?: (Partial
         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;
@@ -1116,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;