react-virtuoso 2.6.0 → 2.8.0-alpha.2

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").
      *
@@ -181,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.
@@ -194,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.
      */
@@ -250,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").
      *
@@ -364,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.
      */
@@ -372,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.
@@ -471,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>;
@@ -528,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>;
@@ -562,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>;
@@ -593,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>;
@@ -636,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>;
@@ -658,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>;
@@ -692,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>;
@@ -705,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>;
@@ -750,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>;
@@ -781,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>;
@@ -821,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>;
@@ -855,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>;
@@ -886,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>;
@@ -929,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>;
@@ -963,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>;
@@ -1014,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>;
@@ -1071,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>;
@@ -1099,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>;
@@ -1115,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>;
@@ -1128,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>;
@@ -1169,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>;
@@ -1203,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>;
@@ -1234,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>;
@@ -1277,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>;
@@ -1320,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>;
@@ -1351,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>;
@@ -1370,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>;
@@ -1383,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>;
@@ -1499,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>;
@@ -1530,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>;
@@ -1549,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>;
@@ -1562,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>;
@@ -1575,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>;
@@ -1641,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>;
@@ -1669,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>;
@@ -1685,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>;
@@ -1698,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>;
@@ -1739,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>;
@@ -1773,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>;
@@ -1804,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>;
@@ -1847,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>;
@@ -1890,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>;
@@ -1921,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>;
@@ -1940,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>;
@@ -1953,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>;
@@ -2072,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>;
@@ -2175,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>;
@@ -2203,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>;
@@ -2219,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>;
@@ -2232,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>;
@@ -2273,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>;
@@ -2307,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>;
@@ -2338,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>;
@@ -2381,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>;
@@ -2424,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>;
@@ -2455,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>;
@@ -2474,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>;
@@ -2487,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>;
@@ -2622,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>;
@@ -2650,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>;
@@ -2666,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>;
@@ -2679,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>;
@@ -2762,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>;
@@ -2790,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>;
@@ -2806,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>;
@@ -2819,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>;
@@ -2860,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>;
@@ -2894,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>;
@@ -2925,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>;
@@ -2968,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>;
@@ -3011,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>;
@@ -3042,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>;
@@ -3061,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>;
@@ -3074,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>;
@@ -3224,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>;
@@ -3237,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>;
@@ -3277,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>;
@@ -3332,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>;
@@ -3360,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>;
@@ -3376,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>;
@@ -3389,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>;
@@ -3430,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>;
@@ -3464,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>;
@@ -3495,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>;
@@ -3538,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>;
@@ -3581,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>;
@@ -3612,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>;
@@ -3631,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>;
@@ -3644,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>;
@@ -3739,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>;
@@ -3772,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>;
@@ -3827,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>;
@@ -3855,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>;
@@ -3871,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>;
@@ -3884,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>;
@@ -3925,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>;
@@ -3959,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>;
@@ -3990,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>;
@@ -4033,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>;
@@ -4076,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>;
@@ -4107,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>;
@@ -4126,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>;
@@ -4139,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>;
@@ -4234,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>;
@@ -4276,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>;
@@ -4295,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>;
@@ -4310,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>;
@@ -4323,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>;
@@ -4378,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>;
@@ -4406,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>;
@@ -4422,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>;
@@ -4435,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>;
@@ -4476,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>;
@@ -4510,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>;
@@ -4541,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>;
@@ -4584,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>;
@@ -4627,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>;
@@ -4658,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>;
@@ -4677,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>;
@@ -4690,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>;
@@ -4785,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>;
@@ -4818,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>;
@@ -4837,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>;
@@ -4850,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>;
@@ -4890,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>;
@@ -4924,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>;
@@ -4955,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>;
@@ -5016,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>;
@@ -5044,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>;
@@ -5060,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>;
@@ -5073,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>;
@@ -5114,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>;
@@ -5148,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>;
@@ -5179,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>;
@@ -5222,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>;
@@ -5265,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>;
@@ -5296,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>;
@@ -5315,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>;
@@ -5328,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>;
@@ -5441,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>;
@@ -5558,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>;
@@ -5630,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>;
@@ -5679,33 +6529,60 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
         groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
         followOutput: import("@virtuoso.dev/urx").StatefulStream<FollowOutput>;
-        totalCount: import("@virtuoso.dev/urx").Stream<number>; /**
-         * Use for server-side rendering - if set, the list will render the specified amount of items
-         * regardless of the container / item size.
-         */
+        totalCount: import("@virtuoso.dev/urx").Stream<number>;
         data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
         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>;
@@ -5716,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>;
@@ -5765,55 +6648,115 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
         groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
         followOutput: import("@virtuoso.dev/urx").StatefulStream<FollowOutput>;
-        totalCount: import("@virtuoso.dev/urx").Stream<number>; /**
-         * Use for server-side rendering - if set, the list will render the specified amount of items
-         * regardless of the container / item size.
-         */
+        totalCount: import("@virtuoso.dev/urx").Stream<number>;
         data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
         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>;
-        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]>;
-        scrollTop: import("@virtuoso.dev/urx").Stream<number>;
-        viewportHeight: import("@virtuoso.dev/urx").Stream<number>;
-        headerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
-        footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
-        scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
-        smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        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]>;
+        scrollTop: import("@virtuoso.dev/urx").Stream<number>;
+        viewportHeight: import("@virtuoso.dev/urx").Stream<number>;
+        headerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
+        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>;
@@ -5863,15 +6806,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
         groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
         followOutput: import("@virtuoso.dev/urx").StatefulStream<FollowOutput>;
-        totalCount: import("@virtuoso.dev/urx").Stream<number>; /**
-         * Use for server-side rendering - if set, the list will render the specified amount of items
-         * regardless of the container / item size.
-         */
+        totalCount: import("@virtuoso.dev/urx").Stream<number>;
         data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
         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[]>;
@@ -5880,6 +6823,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
     }>, {
         required: {};
         optional: {
+            context: "context";
             followOutput: "followOutput";
             firstItemIndex: "firstItemIndex";
             itemContent: "itemContent";
@@ -5895,10 +6839,19 @@ 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";
@@ -5925,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 {};