react-virtuoso 2.5.1 → 2.7.1

package/dist/components.d.ts

@@ -7,7 +7,7 @@ import { ScrollIntoViewLocation } from './scrollIntoViewSystem';
 declare type CompProps<T> = T extends ForwardRefExoticComponent<infer R> ? R : never;
 declare type ListProps = CompProps<typeof List>;
 declare type GridProps = CompProps<typeof Grid>;
-export interface VirtuosoProps<D> extends Omit<ListProps, 'groupCounts' | 'groupContent' | 'itemsRendered'> {
+export interface VirtuosoProps<D, C> extends Omit<ListProps, 'groupCounts' | 'groupContent' | 'itemsRendered'> {
     /**
      * The total amount of items to be rendered.
      */
@@ -16,6 +16,10 @@ export interface VirtuosoProps<D> extends Omit<ListProps, 'groupCounts' | 'group
      * The data items to be rendered. If data is set, the total count will be inferred from the length of the array.
      */
     data?: readonly D[];
+    /**
+     * Additional context available in the custom components and content callbacks
+     */
+    context?: C;
     /**
      * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
      * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
@@ -59,15 +63,15 @@ export interface VirtuosoProps<D> extends Omit<ListProps, 'groupCounts' | 'group
     /**
      * Use the `components` property for advanced customization of the elements rendered by the list.
      */
-    components?: Components;
+    components?: Components<C>;
     /**
      * Set the callback to specify the contents of the item.
      */
-    itemContent?: ItemContent<D>;
+    itemContent?: ItemContent<D, C>;
     /**
      * If specified, the component will use the function to generate the `key` property for each list item.
      */
-    computeItemKey?: ComputeItemKey<D>;
+    computeItemKey?: ComputeItemKey<D, C>;
     /**
      * By default, the component assumes the default item height from the first rendered item (rendering it as a "probe").
      *
@@ -168,6 +172,10 @@ export interface VirtuosoProps<D> extends Omit<ListProps, 'groupCounts' | 'group
      * Uses the document scroller rather than wrapping the list in its own.
      */
     useWindowScroll?: boolean;
+    /**
+     * Pass a reference to a scrollable parent element, so that the list won't wrap in its own.
+     */
+    customScrollParent?: HTMLElement;
     /**
      * Provides access to the root DOM element
      */
@@ -177,7 +185,7 @@ export interface VirtuosoProps<D> extends Omit<ListProps, 'groupCounts' | 'group
      */
     atBottomThreshold?: number;
 }
-export interface GroupedVirtuosoProps<D> extends Omit<VirtuosoProps<D>, 'totalCount' | 'itemContent'>, Pick<ListProps, 'groupCounts' | 'groupContent'> {
+export interface GroupedVirtuosoProps<D, C> extends Omit<VirtuosoProps<D, C>, 'totalCount' | 'itemContent'>, Pick<ListProps, 'groupCounts' | 'groupContent'> {
     /**
      * Specifies the amount of items in each group (and, actually, how many groups are there).
      * For example, passing [20, 30] will display 2 groups with 20 and 30 items each.
@@ -190,13 +198,13 @@ export interface GroupedVirtuosoProps<D> extends Omit<VirtuosoProps<D>, 'totalCo
     /**
      * Specifies how each each item gets rendered.
      */
-    itemContent?: GroupItemContent<D>;
+    itemContent?: GroupItemContent<D, C>;
 }
-export interface TableVirtuosoProps<D> extends Omit<VirtuosoProps<D>, 'components' | 'headerFooterTag' | 'topItemCount'> {
+export interface TableVirtuosoProps<D, C> extends Omit<VirtuosoProps<D, C>, 'components' | 'headerFooterTag' | 'topItemCount'> {
     /**
      * Use the `components` property for advanced customization of the elements rendered by the table.
      */
-    components?: TableComponents;
+    components?: TableComponents<C>;
     /**
      * Set the contents of the table header.
      */
@@ -246,11 +254,11 @@ export interface TableVirtuosoProps<D> extends Omit<VirtuosoProps<D>, 'component
     /**
      * Set the callback to specify the contents of the item.
      */
-    itemContent?: ItemContent<D>;
+    itemContent?: ItemContent<D, C>;
     /**
      * If specified, the component will use the function to generate the `key` property for each list item.
      */
-    computeItemKey?: ComputeItemKey<D>;
+    computeItemKey?: ComputeItemKey<D, C>;
     /**
      * By default, the component assumes the default item height from the first rendered item (rendering it as a "probe").
      *
@@ -347,6 +355,10 @@ export interface TableVirtuosoProps<D> extends Omit<VirtuosoProps<D>, 'component
      * Uses the document scroller rather than wrapping the list in its own.
      */
     useWindowScroll?: boolean;
+    /**
+     * Pass a reference to a scrollable parent element, so that the table won't wrap in its own.
+     */
+    customScrollParent?: HTMLElement;
     /**
      * Provides access to the root DOM element
      */
@@ -356,7 +368,7 @@ export interface TableVirtuosoProps<D> extends Omit<VirtuosoProps<D>, 'component
      */
     atBottomThreshold?: number;
 }
-export interface VirtuosoGridProps extends GridProps {
+export interface VirtuosoGridProps<C extends unknown = unknown> extends GridProps {
     /**
      * The total amount of items to be rendered.
      */
@@ -364,11 +376,11 @@ export interface VirtuosoGridProps extends GridProps {
     /**
      * Set the callback to specify the contents of the item.
      */
-    itemContent?: GridItemContent;
+    itemContent?: GridItemContent<C>;
     /**
      * Use the `components` property for advanced customization of the elements rendered by the list.
      */
-    components?: GridComponents;
+    components?: GridComponents<C>;
     /**
      * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
      * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
@@ -430,6 +442,10 @@ export interface VirtuosoGridProps extends GridProps {
      * Uses the document scroller rather than wrapping the grid in its own.
      */
     useWindowScroll?: boolean;
+    /**
+     * Pass a reference to a scrollable parent element, so that the grid won't wrap in its own.
+     */
+    customScrollParent?: HTMLElement;
 }
 export interface VirtuosoHandle extends ListHandle {
     /**
@@ -459,13 +475,13 @@ export interface VirtuosoGridHandle extends GridHandle {
     scrollTo(location: ScrollToOptions): void;
     scrollBy(location: ScrollToOptions): void;
 }
-export declare const Virtuoso: <D extends unknown = any>(props: VirtuosoProps<D> & {
+export declare const Virtuoso: <ItemData extends unknown = any, Context extends unknown = any>(props: VirtuosoProps<ItemData, Context> & {
     ref?: Ref<VirtuosoHandle> | undefined;
 }) => ReactElement;
-export declare const GroupedVirtuoso: <D extends unknown = any>(props: GroupedVirtuosoProps<D> & {
+export declare const GroupedVirtuoso: <ItemData extends unknown = any, Context extends unknown = any>(props: GroupedVirtuosoProps<ItemData, Context> & {
     ref?: Ref<GroupedVirtuosoHandle> | undefined;
 }) => ReactElement;
-export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuosoProps<D> & {
+export declare const TableVirtuoso: <ItemData extends unknown = any, Context extends unknown = any>(props: TableVirtuosoProps<ItemData, Context> & {
     ref?: Ref<import("@virtuoso.dev/react-urx").MethodsFromPropMap<import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
         log: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").Log>;
         logLevel: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").LogLevel>;
@@ -484,6 +500,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -504,6 +521,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -514,6 +532,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -537,6 +561,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -547,6 +572,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -567,6 +598,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -577,6 +609,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -609,6 +647,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -619,6 +658,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -641,6 +686,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -664,6 +715,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -674,6 +726,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -687,6 +745,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -721,6 +785,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -731,6 +796,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -751,6 +822,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -761,6 +833,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -790,6 +868,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -800,6 +879,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -823,6 +908,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -833,6 +919,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -853,6 +945,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -863,6 +956,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -895,6 +994,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -905,6 +1005,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -939,6 +1045,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -956,6 +1068,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -989,6 +1102,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1014,6 +1133,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -1034,6 +1154,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -1044,6 +1165,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1061,6 +1188,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -1071,6 +1199,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1087,6 +1221,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1100,6 +1240,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1130,6 +1276,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -1140,6 +1287,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1163,6 +1316,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -1173,6 +1327,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1193,6 +1353,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -1203,6 +1364,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1235,6 +1402,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -1245,6 +1413,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1277,6 +1451,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -1287,6 +1462,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1307,6 +1488,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -1317,6 +1499,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1336,6 +1524,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1349,6 +1543,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1386,6 +1586,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -1453,6 +1654,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -1463,6 +1665,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1483,6 +1691,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -1493,6 +1702,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1512,6 +1727,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1525,6 +1746,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1538,6 +1765,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1572,6 +1805,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -1592,6 +1826,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -1602,6 +1837,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1619,6 +1860,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -1629,6 +1871,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1645,6 +1893,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1658,6 +1912,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1688,6 +1948,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -1698,6 +1959,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1721,6 +1988,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -1731,6 +1999,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1751,6 +2025,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -1761,6 +2036,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1793,6 +2074,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -1803,6 +2085,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1835,6 +2123,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -1845,6 +2134,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1865,6 +2160,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -1875,6 +2171,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1894,6 +2196,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1907,6 +2215,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1944,6 +2258,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -2011,6 +2326,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -2024,6 +2340,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2069,6 +2391,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -2094,6 +2417,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -2114,6 +2438,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -2124,6 +2449,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2141,6 +2472,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -2151,6 +2483,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2167,6 +2505,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2180,6 +2524,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2210,6 +2560,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -2220,6 +2571,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2243,6 +2600,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -2253,6 +2611,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2273,6 +2637,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -2283,6 +2648,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2315,6 +2686,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -2325,6 +2697,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2357,6 +2735,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -2367,6 +2746,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2387,6 +2772,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -2397,6 +2783,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2416,6 +2808,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2429,6 +2827,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2466,6 +2870,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -2552,6 +2957,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -2562,6 +2968,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2579,6 +2991,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -2589,6 +3002,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2605,6 +3024,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2618,6 +3043,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2648,6 +3079,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -2668,6 +3100,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -2688,6 +3121,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -2698,6 +3132,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2715,6 +3155,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -2725,6 +3166,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2741,6 +3188,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2754,6 +3207,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2784,6 +3243,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -2794,6 +3254,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2817,6 +3283,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -2827,6 +3294,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2847,6 +3320,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -2857,6 +3331,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2889,6 +3369,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -2899,6 +3380,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2931,6 +3418,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -2941,6 +3429,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2961,6 +3455,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -2971,6 +3466,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2990,6 +3491,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3003,6 +3510,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3040,6 +3553,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -3110,6 +3624,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -3151,6 +3666,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3164,6 +3685,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3204,6 +3731,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3227,6 +3760,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -3247,6 +3781,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -3257,6 +3792,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3274,6 +3815,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -3284,6 +3826,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3300,6 +3848,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3313,6 +3867,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3343,6 +3903,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -3353,6 +3914,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3376,6 +3943,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -3386,6 +3954,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3406,6 +3980,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -3416,6 +3991,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3448,6 +4029,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -3458,6 +4040,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3490,6 +4078,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -3500,6 +4089,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3520,6 +4115,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -3530,6 +4126,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3549,6 +4151,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3562,6 +4170,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3599,6 +4213,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -3656,6 +4271,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3689,6 +4310,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3712,6 +4339,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -3732,6 +4360,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -3742,6 +4371,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3759,6 +4394,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -3769,6 +4405,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3785,6 +4427,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3798,6 +4446,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3828,6 +4482,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -3838,6 +4493,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3861,6 +4522,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -3871,6 +4533,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3891,6 +4559,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -3901,6 +4570,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3933,6 +4608,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -3943,6 +4619,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3975,6 +4657,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -3985,6 +4668,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4005,6 +4694,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -4015,6 +4705,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4034,6 +4730,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4047,6 +4749,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4084,6 +4792,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -4141,6 +4850,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4183,6 +4898,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4202,6 +4923,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4217,6 +4944,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4230,6 +4963,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4253,6 +4992,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -4273,6 +5013,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -4283,6 +5024,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4300,6 +5047,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -4310,6 +5058,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4326,6 +5080,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4339,6 +5099,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4369,6 +5135,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -4379,6 +5146,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4402,6 +5175,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -4412,6 +5186,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4432,6 +5212,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -4442,6 +5223,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4474,6 +5261,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -4484,6 +5272,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4516,6 +5310,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -4526,6 +5321,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4546,6 +5347,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -4556,6 +5358,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4575,6 +5383,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4588,6 +5402,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4625,6 +5445,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -4682,6 +5503,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4715,6 +5542,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4734,6 +5567,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4747,6 +5586,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4754,6 +5599,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         scrollingInProgress: import("@virtuoso.dev/urx").StatefulStream<boolean>;
     }]) => {
         useWindowScroll: import("@virtuoso.dev/urx").StatefulStream<boolean>;
+        customScrollParent: import("@virtuoso.dev/urx").StatefulStream<HTMLElement | undefined>;
         windowScrollContainerState: import("@virtuoso.dev/urx").Stream<[number, number]>;
         windowViewportRect: import("@virtuoso.dev/urx").Stream<import("./interfaces").WindowViewportInfo>;
         windowScrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4775,6 +5621,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -4785,6 +5632,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4808,6 +5661,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -4818,6 +5672,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4838,6 +5698,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -4848,6 +5709,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4877,6 +5744,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -4897,6 +5765,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -4907,6 +5776,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4924,6 +5799,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -4934,6 +5810,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4950,6 +5832,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4963,6 +5851,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4993,6 +5887,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -5003,6 +5898,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -5026,6 +5927,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -5036,6 +5938,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -5056,6 +5964,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -5066,6 +5975,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -5098,6 +6013,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -5108,6 +6024,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -5140,6 +6062,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
@@ -5150,6 +6073,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -5170,6 +6099,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -5180,6 +6110,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -5199,6 +6135,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -5212,6 +6154,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -5249,6 +6197,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -5313,6 +6262,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -5323,6 +6273,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -5380,6 +6336,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         paddingTopAddition: import("@virtuoso.dev/urx").StatefulStream<number>;
     }, {
         useWindowScroll: import("@virtuoso.dev/urx").StatefulStream<boolean>;
+        customScrollParent: import("@virtuoso.dev/urx").StatefulStream<HTMLElement | undefined>;
         windowScrollContainerState: import("@virtuoso.dev/urx").Stream<[number, number]>;
         windowViewportRect: import("@virtuoso.dev/urx").Stream<import("./interfaces").WindowViewportInfo>;
         windowScrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5388,6 +6345,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
     }]) => {
         scrollIntoView: import("@virtuoso.dev/urx").Stream<ScrollIntoViewLocation>;
         useWindowScroll: import("@virtuoso.dev/urx").StatefulStream<boolean>;
+        customScrollParent: import("@virtuoso.dev/urx").StatefulStream<HTMLElement | undefined>;
         windowScrollContainerState: import("@virtuoso.dev/urx").Stream<[number, number]>;
         windowViewportRect: import("@virtuoso.dev/urx").Stream<import("./interfaces").WindowViewportInfo>;
         windowScrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5412,7 +6370,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
     }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
         log: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").Log>;
         logLevel: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").LogLevel>;
-    }>], ([{ totalCount, sizeRanges, fixedItemSize, defaultItemSize, trackItemSizes, itemSize, data, firstItemIndex, groupIndices }, { initialTopMostItemIndex, scrolledToInitialItem }, domIO, followOutput, { listState, topItemsIndexes, ...flags }, { scrollToIndex }, _, { topItemCount }, { groupCounts }, featureGroup1, log,]: [{
+    }>], ([{ totalCount, sizeRanges, fixedItemSize, defaultItemSize, trackItemSizes, itemSize, data, firstItemIndex, groupIndices, statefulTotalCount, }, { initialTopMostItemIndex, scrolledToInitialItem }, domIO, followOutput, { listState, topItemsIndexes, ...flags }, { scrollToIndex }, _, { topItemCount }, { groupCounts }, featureGroup1, log,]: [{
         data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
         totalCount: import("@virtuoso.dev/urx").Stream<number>;
         sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
@@ -5424,6 +6382,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
         listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
     }, {
@@ -5437,6 +6396,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -5474,6 +6439,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
     }, {
         scrollIntoView: import("@virtuoso.dev/urx").Stream<ScrollIntoViewLocation>;
         useWindowScroll: import("@virtuoso.dev/urx").StatefulStream<boolean>;
+        customScrollParent: import("@virtuoso.dev/urx").StatefulStream<HTMLElement | undefined>;
         windowScrollContainerState: import("@virtuoso.dev/urx").Stream<[number, number]>;
         windowViewportRect: import("@virtuoso.dev/urx").Stream<import("./interfaces").WindowViewportInfo>;
         windowScrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5508,6 +6474,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -5515,6 +6487,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         scrollingInProgress: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         scrollIntoView: import("@virtuoso.dev/urx").Stream<ScrollIntoViewLocation>;
         useWindowScroll: import("@virtuoso.dev/urx").StatefulStream<boolean>;
+        customScrollParent: import("@virtuoso.dev/urx").StatefulStream<HTMLElement | undefined>;
         windowScrollContainerState: import("@virtuoso.dev/urx").Stream<[number, number]>;
         windowViewportRect: import("@virtuoso.dev/urx").Stream<import("./interfaces").WindowViewportInfo>;
         windowScrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5549,6 +6522,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         startReached: import("@virtuoso.dev/urx").Stream<number>;
         rangeChanged: import("@virtuoso.dev/urx").Stream<ListRange>;
         itemsRendered: import("@virtuoso.dev/urx").Stream<import("./listStateSystem").ListItems>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         listState: import("@virtuoso.dev/urx").StatefulStream<import("./listStateSystem").ListState>;
         scrollToIndex: import("@virtuoso.dev/urx").Stream<import("./scrollToIndexSystem").IndexLocation>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
@@ -5560,25 +6534,55 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
         initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
-        scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
+        scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>; /**
+         * Use for server-side rendering - if set, the list will render the specified amount of items
+         * regardless of the container / item size.
+         */
         topItemsIndexes: import("@virtuoso.dev/urx").StatefulStream<number[]>;
         topItemCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         groupCounts: import("@virtuoso.dev/urx").Stream<number[]>;
         fixedItemHeight: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
         defaultItemHeight: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
     }>, import("@virtuoso.dev/urx").SystemSpec<import("@virtuoso.dev/urx").SystemSpecs, () => {
-        itemContent: import("@virtuoso.dev/urx").StatefulStream<ItemContent<any>>;
+        context: import("@virtuoso.dev/urx").StatefulStream<unknown>;
+        itemContent: import("@virtuoso.dev/urx").StatefulStream<ItemContent<any, unknown>>;
         fixedHeaderContent: import("@virtuoso.dev/urx").StatefulStream<FixedHeaderContent>;
-        components: import("@virtuoso.dev/urx").StatefulStream<TableComponents>;
-        computeItemKey: import("@virtuoso.dev/urx").StatefulStream<ComputeItemKey<any>>;
+        components: import("@virtuoso.dev/urx").StatefulStream<TableComponents<unknown>>;
+        computeItemKey: import("@virtuoso.dev/urx").StatefulStream<ComputeItemKey<any, unknown>>;
         scrollerRef: import("@virtuoso.dev/urx").StatefulStream<(ref: HTMLElement | Window | null) => void>;
-        TableComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").TableProps> | null | undefined>;
-        TableHeadComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<{}> | null | undefined>;
-        TableBodyComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ListProps> | null | undefined>;
-        TableRowComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ItemProps> | null | undefined>;
-        ScrollerComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ScrollerProps> | null | undefined>;
-        EmptyPlaceholder: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<{}> | null | undefined>;
-        ScrollSeekPlaceholder: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ScrollSeekPlaceholderProps> | null | undefined>;
+        TableComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").TableProps & {
+            context?: unknown;
+        }> | null | undefined>;
+        TableHeadComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<{
+            context?: unknown;
+        }> | null | undefined>;
+        TableBodyComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<Pick<Pick<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof import("react").HTMLAttributes<HTMLDivElement>> & {
+            ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+        }, "ref" | "style" | "children"> & {
+            /**
+             * Additional context available in the custom components and content callbacks
+             */
+            'data-test-id': string;
+        } & {
+            context?: unknown;
+        }> | null | undefined>;
+        TableRowComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ItemProps & {
+            context?: unknown;
+        }> | null | undefined>;
+        ScrollerComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<Pick<Pick<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof import("react").HTMLAttributes<HTMLDivElement>> & {
+            ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+        }, "ref" | "style" | "tabIndex" | "children"> & {
+            'data-test-id'?: string | undefined;
+            'data-virtuoso-scroller'?: boolean | undefined;
+        } & {
+            context?: unknown;
+        }> | null | undefined>;
+        EmptyPlaceholder: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<{
+            context?: unknown;
+        }> | null | undefined>;
+        ScrollSeekPlaceholder: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ScrollSeekPlaceholderProps & {
+            context?: unknown;
+        }> | null | undefined>;
     }>], ([listSystem, propsSystem]: [{
         log: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").Log>;
         logLevel: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").LogLevel>;
@@ -5589,6 +6593,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -5596,6 +6606,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         scrollingInProgress: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         scrollIntoView: import("@virtuoso.dev/urx").Stream<ScrollIntoViewLocation>;
         useWindowScroll: import("@virtuoso.dev/urx").StatefulStream<boolean>;
+        customScrollParent: import("@virtuoso.dev/urx").StatefulStream<HTMLElement | undefined>;
         windowScrollContainerState: import("@virtuoso.dev/urx").Stream<[number, number]>;
         windowViewportRect: import("@virtuoso.dev/urx").Stream<import("./interfaces").WindowViewportInfo>;
         windowScrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5630,6 +6641,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         startReached: import("@virtuoso.dev/urx").Stream<number>;
         rangeChanged: import("@virtuoso.dev/urx").Stream<ListRange>;
         itemsRendered: import("@virtuoso.dev/urx").Stream<import("./listStateSystem").ListItems>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         listState: import("@virtuoso.dev/urx").StatefulStream<import("./listStateSystem").ListState>;
         scrollToIndex: import("@virtuoso.dev/urx").Stream<import("./scrollToIndexSystem").IndexLocation>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
@@ -5641,38 +6653,95 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
         initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
-        scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
+        scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>; /**
+         * Use for server-side rendering - if set, the list will render the specified amount of items
+         * regardless of the container / item size.
+         */
         topItemsIndexes: import("@virtuoso.dev/urx").StatefulStream<number[]>;
         topItemCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         groupCounts: import("@virtuoso.dev/urx").Stream<number[]>;
         fixedItemHeight: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
         defaultItemHeight: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
     }, {
-        itemContent: import("@virtuoso.dev/urx").StatefulStream<ItemContent<any>>;
+        context: import("@virtuoso.dev/urx").StatefulStream<unknown>;
+        itemContent: import("@virtuoso.dev/urx").StatefulStream<ItemContent<any, unknown>>;
         fixedHeaderContent: import("@virtuoso.dev/urx").StatefulStream<FixedHeaderContent>;
-        components: import("@virtuoso.dev/urx").StatefulStream<TableComponents>;
-        computeItemKey: import("@virtuoso.dev/urx").StatefulStream<ComputeItemKey<any>>;
+        components: import("@virtuoso.dev/urx").StatefulStream<TableComponents<unknown>>;
+        computeItemKey: import("@virtuoso.dev/urx").StatefulStream<ComputeItemKey<any, unknown>>;
         scrollerRef: import("@virtuoso.dev/urx").StatefulStream<(ref: HTMLElement | Window | null) => void>;
-        TableComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").TableProps> | null | undefined>;
-        TableHeadComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<{}> | null | undefined>;
-        TableBodyComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ListProps> | null | undefined>;
-        TableRowComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ItemProps> | null | undefined>;
-        ScrollerComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ScrollerProps> | null | undefined>;
-        EmptyPlaceholder: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<{}> | null | undefined>;
-        ScrollSeekPlaceholder: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ScrollSeekPlaceholderProps> | null | undefined>;
-    }]) => {
-        itemContent: import("@virtuoso.dev/urx").StatefulStream<ItemContent<any>>;
+        TableComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").TableProps & {
+            context?: unknown;
+        }> | null | undefined>;
+        TableHeadComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<{
+            context?: unknown;
+        }> | null | undefined>;
+        TableBodyComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<Pick<Pick<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof import("react").HTMLAttributes<HTMLDivElement>> & {
+            ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+        }, "ref" | "style" | "children"> & {
+            /**
+             * Additional context available in the custom components and content callbacks
+             */
+            'data-test-id': string;
+        } & {
+            context?: unknown;
+        }> | null | undefined>;
+        TableRowComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ItemProps & {
+            context?: unknown;
+        }> | null | undefined>;
+        ScrollerComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<Pick<Pick<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof import("react").HTMLAttributes<HTMLDivElement>> & {
+            ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+        }, "ref" | "style" | "tabIndex" | "children"> & {
+            'data-test-id'?: string | undefined;
+            'data-virtuoso-scroller'?: boolean | undefined;
+        } & {
+            context?: unknown;
+        }> | null | undefined>;
+        EmptyPlaceholder: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<{
+            context?: unknown;
+        }> | null | undefined>;
+        ScrollSeekPlaceholder: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ScrollSeekPlaceholderProps & {
+            context?: unknown;
+        }> | null | undefined>;
+    }]) => {
+        context: import("@virtuoso.dev/urx").StatefulStream<unknown>;
+        itemContent: import("@virtuoso.dev/urx").StatefulStream<ItemContent<any, unknown>>;
         fixedHeaderContent: import("@virtuoso.dev/urx").StatefulStream<FixedHeaderContent>;
-        components: import("@virtuoso.dev/urx").StatefulStream<TableComponents>;
-        computeItemKey: import("@virtuoso.dev/urx").StatefulStream<ComputeItemKey<any>>;
+        components: import("@virtuoso.dev/urx").StatefulStream<TableComponents<unknown>>;
+        computeItemKey: import("@virtuoso.dev/urx").StatefulStream<ComputeItemKey<any, unknown>>;
         scrollerRef: import("@virtuoso.dev/urx").StatefulStream<(ref: HTMLElement | Window | null) => void>;
-        TableComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").TableProps> | null | undefined>;
-        TableHeadComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<{}> | null | undefined>;
-        TableBodyComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ListProps> | null | undefined>;
-        TableRowComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ItemProps> | null | undefined>;
-        ScrollerComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ScrollerProps> | null | undefined>;
-        EmptyPlaceholder: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<{}> | null | undefined>;
-        ScrollSeekPlaceholder: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ScrollSeekPlaceholderProps> | null | undefined>;
+        TableComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").TableProps & {
+            context?: unknown;
+        }> | null | undefined>;
+        TableHeadComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<{
+            context?: unknown;
+        }> | null | undefined>;
+        TableBodyComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<Pick<Pick<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof import("react").HTMLAttributes<HTMLDivElement>> & {
+            ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+        }, "ref" | "style" | "children"> & {
+            /**
+             * Additional context available in the custom components and content callbacks
+             */
+            'data-test-id': string;
+        } & {
+            context?: unknown;
+        }> | null | undefined>;
+        TableRowComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ItemProps & {
+            context?: unknown;
+        }> | null | undefined>;
+        ScrollerComponent: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<Pick<Pick<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof import("react").HTMLAttributes<HTMLDivElement>> & {
+            ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+        }, "ref" | "style" | "tabIndex" | "children"> & {
+            'data-test-id'?: string | undefined;
+            'data-virtuoso-scroller'?: boolean | undefined;
+        } & {
+            context?: unknown;
+        }> | null | undefined>;
+        EmptyPlaceholder: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<{
+            context?: unknown;
+        }> | null | undefined>;
+        ScrollSeekPlaceholder: import("@virtuoso.dev/urx").StatefulStream<"div" | "table" | "tbody" | "thead" | "tr" | import("react").ComponentType<import("./interfaces").ScrollSeekPlaceholderProps & {
+            context?: unknown;
+        }> | null | undefined>;
         log: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").Log>;
         logLevel: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").LogLevel>;
         scrollContainerState: import("@virtuoso.dev/urx").Stream<[number, number]>;
@@ -5682,6 +6751,12 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+         */
         scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
         statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -5689,6 +6764,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         scrollingInProgress: import("@virtuoso.dev/urx").StatefulStream<boolean>;
         scrollIntoView: import("@virtuoso.dev/urx").Stream<ScrollIntoViewLocation>;
         useWindowScroll: import("@virtuoso.dev/urx").StatefulStream<boolean>;
+        customScrollParent: import("@virtuoso.dev/urx").StatefulStream<HTMLElement | undefined>;
         windowScrollContainerState: import("@virtuoso.dev/urx").Stream<[number, number]>;
         windowViewportRect: import("@virtuoso.dev/urx").Stream<import("./interfaces").WindowViewportInfo>;
         windowScrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5723,6 +6799,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         startReached: import("@virtuoso.dev/urx").Stream<number>;
         rangeChanged: import("@virtuoso.dev/urx").Stream<ListRange>;
         itemsRendered: import("@virtuoso.dev/urx").Stream<import("./listStateSystem").ListItems>;
+        statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         listState: import("@virtuoso.dev/urx").StatefulStream<import("./listStateSystem").ListState>;
         scrollToIndex: import("@virtuoso.dev/urx").Stream<import("./scrollToIndexSystem").IndexLocation>;
         trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
@@ -5734,7 +6811,10 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
         sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
         initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
-        scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
+        scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>; /**
+         * Use for server-side rendering - if set, the list will render the specified amount of items
+         * regardless of the container / item size.
+         */
         topItemsIndexes: import("@virtuoso.dev/urx").StatefulStream<number[]>;
         topItemCount: import("@virtuoso.dev/urx").StatefulStream<number>;
         groupCounts: import("@virtuoso.dev/urx").Stream<number[]>;
@@ -5743,6 +6823,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
     }>, {
         required: {};
         optional: {
+            context: "context";
             followOutput: "followOutput";
             firstItemIndex: "firstItemIndex";
             itemContent: "itemContent";
@@ -5758,13 +6839,23 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
             computeItemKey: "computeItemKey";
             defaultItemHeight: "defaultItemHeight";
             fixedItemHeight: "fixedItemHeight";
+            /**
+             * The data items to be rendered. If data is set, the total count will be inferred from the length of the array.
+             */
             itemSize: "itemSize";
             scrollSeekConfiguration: "scrollSeekConfiguration";
             data: "data";
             initialItemCount: "initialItemCount";
+            /**
+             * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+             * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+             * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+             * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+             */
             initialScrollTop: "initialScrollTop";
             alignToBottom: "alignToBottom";
             useWindowScroll: "useWindowScroll";
+            customScrollParent: "customScrollParent";
             scrollerRef: "scrollerRef";
             logLevel: "logLevel";
         };
@@ -5787,7 +6878,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         };
     }>> | undefined;
 }) => ReactElement;
-export declare const VirtuosoGrid: (props: VirtuosoGridProps & {
-    ref?: Ref<VirtuosoGridHandle>;
+export declare const VirtuosoGrid: <Context extends unknown = any>(props: VirtuosoGridProps<Context> & {
+    ref?: Ref<VirtuosoGridHandle> | undefined;
 }) => ReactElement;
 export {};