react-virtuoso 2.6.0 → 2.7.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.
      */
@@ -17,19 +17,30 @@ export interface VirtuosoProps<D> extends Omit<ListProps, 'groupCounts' | 'group
      */
     data?: readonly D[];
     /**
+     * Additional context available in the custom components and content callbacks
+     */
+    context?: C;
+    /**
+     * *The property accepts pixel values.*
+     *
      * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
      * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
      * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
-     * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
+     * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
+     *
      */
     overscan?: number | {
         main: number;
         reverse: number;
     };
     /**
+     *
+     * *The property accepts pixel values.*
+     *
      * Set the increaseViewportBy property to artificially increase the viewport size, causing items to be rendered before outside of the viewport.
      * The property causes the component to render more items than the necessary, but can help with slow loading content.
      * Using `{ top?: number, bottom?: number }` lets you set the increase for each end separately.
+     *
      */
     increaseViewportBy?: number | {
         top: number;
@@ -59,15 +70,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 +192,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 +205,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 +261,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 +375,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 +383,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 +482,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 +539,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +582,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +622,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +674,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +705,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +748,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +770,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +824,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +864,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +913,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +956,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +996,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1048,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1091,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1151,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1217,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1254,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1279,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1301,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1351,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1394,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1434,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1486,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1538,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1578,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1606,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1628,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1753,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1793,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1821,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1843,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1865,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1940,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +1977,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2002,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2024,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2074,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2117,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2157,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2209,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2261,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2301,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2329,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2351,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2479,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2591,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2628,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2653,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2675,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2725,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2768,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2808,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2860,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2912,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2952,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +2980,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3002,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3146,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3183,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3208,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3230,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3322,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3359,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3384,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3406,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3456,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3499,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3539,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3591,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3643,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3683,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3711,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3733,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3892,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3914,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +3963,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4027,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4064,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4089,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4111,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4161,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4204,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4244,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4296,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4348,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4388,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4416,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4438,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4542,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4584,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4648,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4685,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4710,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4732,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4782,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4825,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4865,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4917,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +4969,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5009,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5037,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5059,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5163,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5214,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5242,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5266,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5288,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5352,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5389,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5414,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5436,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5486,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5529,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5569,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5621,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5673,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5713,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5741,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5763,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5867,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5909,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5937,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +5959,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6008,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6051,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6091,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6161,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6198,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6223,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6245,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6295,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6338,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6378,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6430,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6482,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6522,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6550,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6572,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6694,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6820,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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 +6901,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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,10 +6959,7 @@ 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[]>;
@@ -5694,18 +6971,45 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         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 +7020,15 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
         scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
         smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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,10 +7078,7 @@ 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[]>;
@@ -5780,40 +7090,103 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
         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>;
+        /**
+         * *The property accepts pixel values.*
+         *
+         * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
+         * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
+         * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
+         * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` 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,10 +7236,7 @@ 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[]>;
@@ -5880,6 +7250,7 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
     }>, {
         required: {};
         optional: {
+            context: "context";
             followOutput: "followOutput";
             firstItemIndex: "firstItemIndex";
             itemContent: "itemContent";
@@ -5895,9 +7266,14 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
             computeItemKey: "computeItemKey";
             defaultItemHeight: "defaultItemHeight";
             fixedItemHeight: "fixedItemHeight";
-            itemSize: "itemSize";
+            itemSize: "itemSize"; /**
+             * The total amount of items to be rendered.
+             */
             scrollSeekConfiguration: "scrollSeekConfiguration";
             data: "data";
+            /**
+             * The data items to be rendered. If data is set, the total count will be inferred from the length of the array.
+             */
             initialItemCount: "initialItemCount";
             initialScrollTop: "initialScrollTop";
             alignToBottom: "alignToBottom";
@@ -5918,14 +7294,18 @@ export declare const TableVirtuoso: <D extends unknown = any>(props: TableVirtuo
             startReached: "startReached";
             rangeChanged: "rangeChanged";
             atBottomStateChange: "atBottomStateChange";
-            atTopStateChange: "atTopStateChange";
+            atTopStateChange: "atTopStateChange"; /**
+             * Set the increaseViewportBy property to artificially increase the viewport size, causing items to be rendered before outside of the viewport.
+             * The property causes the component to render more items than the necessary, but can help with slow loading content.
+             * Using `{ top?: number, bottom?: number }` lets you set the increase for each end separately.
+             */
             totalListHeightChanged: "totalListHeightChanged";
             itemsRendered: "itemsRendered";
             groupIndices: "groupIndices";
         };
     }>> | 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 {};