react-virtuoso 2.8.0-alpha.2 → 2.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (68) hide show
  1. package/dist/AATree.d.ts +40 -40
  2. package/dist/Grid.d.ts +482 -482
  3. package/dist/List.d.ts +6253 -6041
  4. package/dist/Table.d.ts +6087 -5875
  5. package/dist/alignToBottomSystem.d.ts +549 -529
  6. package/dist/comparators.d.ts +3 -3
  7. package/dist/components.d.ts +1158 -296
  8. package/dist/domIOSystem.d.ts +15 -15
  9. package/dist/followOutputSystem.d.ts +378 -362
  10. package/dist/gridSystem.d.ts +281 -281
  11. package/dist/groupedListSystem.d.ts +75 -71
  12. package/dist/hooks/__mocks__/useChangedChildSizes.d.ts +4 -4
  13. package/dist/hooks/__mocks__/useScrollTop.d.ts +7 -7
  14. package/dist/hooks/__mocks__/useSize.d.ts +3 -3
  15. package/dist/hooks/useChangedChildSizes.d.ts +3 -3
  16. package/dist/hooks/useIsomorphicLayoutEffect.d.ts +3 -3
  17. package/dist/hooks/useScrollTop.d.ts +6 -6
  18. package/dist/hooks/useSize.d.ts +6 -6
  19. package/dist/hooks/useWindowViewportRect.d.ts +2 -2
  20. package/dist/index.d.ts +3 -3
  21. package/dist/index.js +1 -1
  22. package/dist/index.js.map +1 -1
  23. package/dist/index.m.js +1 -1
  24. package/dist/index.m.js.map +1 -1
  25. package/dist/initialItemCountSystem.d.ts +542 -518
  26. package/dist/initialScrollTopSystem.d.ts +560 -540
  27. package/dist/initialTopMostItemIndexSystem.d.ts +163 -153
  28. package/dist/interfaces.d.ts +279 -279
  29. package/dist/listStateSystem.d.ts +489 -469
  30. package/dist/listSystem.d.ts +5426 -5214
  31. package/dist/loggerSystem.d.ts +17 -17
  32. package/dist/propsReadySystem.d.ts +12 -12
  33. package/dist/scrollIntoViewSystem.d.ts +645 -617
  34. package/dist/scrollSeekSystem.d.ts +57 -57
  35. package/dist/scrollToIndexSystem.d.ts +81 -77
  36. package/dist/sizeRangeSystem.d.ts +50 -50
  37. package/dist/sizeSystem.d.ts +68 -66
  38. package/dist/stateFlagsSystem.d.ts +65 -65
  39. package/dist/topItemCountSystem.d.ts +489 -469
  40. package/dist/totalListHeightSystem.d.ts +517 -497
  41. package/dist/upwardScrollFixSystem.d.ts +614 -590
  42. package/dist/utils/binaryArraySearch.d.ts +6 -6
  43. package/dist/utils/correctItemSize.d.ts +1 -1
  44. package/dist/utils/positionStickyCssValue.d.ts +1 -1
  45. package/dist/utils/simpleMemoize.d.ts +1 -1
  46. package/dist/windowScrollerSystem.d.ts +35 -35
  47. package/package.json +5 -15
  48. package/dist/TableVirtuoso.js +0 -2
  49. package/dist/TableVirtuoso.js.map +0 -1
  50. package/dist/TableVirtuoso.mjs +0 -2
  51. package/dist/TableVirtuoso.mjs.map +0 -1
  52. package/dist/VirtuosoGrid.js +0 -2
  53. package/dist/VirtuosoGrid.js.map +0 -1
  54. package/dist/VirtuosoGrid.mjs +0 -2
  55. package/dist/VirtuosoGrid.mjs.map +0 -1
  56. package/dist/components/CompProps.d.ts +0 -2
  57. package/dist/components/GroupedVirtuoso.d.ts +0 -27
  58. package/dist/components/TableVirtuoso.d.ts +0 -5717
  59. package/dist/components/Virtuoso.d.ts +0 -205
  60. package/dist/components/VirtuosoGrid.d.ts +0 -93
  61. package/dist/components/index.d.ts +0 -4
  62. package/dist/index-27.js +0 -2
  63. package/dist/index.mjs +0 -2
  64. package/dist/index.mjs.map +0 -1
  65. package/dist/shared.js +0 -2
  66. package/dist/shared.js.map +0 -1
  67. package/dist/shared.mjs +0 -2
  68. package/dist/shared.mjs.map +0 -1
package/dist/components.d.ts CHANGED
@@ -21,19 +21,26 @@ export interface VirtuosoProps<D, C> extends Omit<ListProps, 'groupCounts' | 'gr
21
21
  */
22
22
  context?: C;
23
23
  /**
24
+ * *The property accepts pixel values.*
25
+ *
24
26
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
25
27
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
26
28
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
27
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
29
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
30
+ *
28
31
  */
29
32
  overscan?: number | {
30
33
  main: number;
31
34
  reverse: number;
32
35
  };
33
36
  /**
37
+ *
38
+ * *The property accepts pixel values.*
39
+ *
34
40
  * Set the increaseViewportBy property to artificially increase the viewport size, causing items to be rendered before outside of the viewport.
35
41
  * The property causes the component to render more items than the necessary, but can help with slow loading content.
36
42
  * Using `{ top?: number, bottom?: number }` lets you set the increase for each end separately.
43
+ *
37
44
  */
38
45
  increaseViewportBy?: number | {
39
46
  top: number;
@@ -47,8 +54,9 @@ export interface VirtuosoProps<D, C> extends Omit<ListProps, 'groupCounts' | 'gr
47
54
  topItemCount?: number;
48
55
  /**
49
56
  * Set to a value between 0 and totalCount - 1 to make the list start scrolled to that item.
57
+ * Pass in an object to achieve additional effects similar to `scrollToIndex`.
50
58
  */
51
- initialTopMostItemIndex?: number;
59
+ initialTopMostItemIndex?: number | IndexLocationWithAlign;
52
60
  /**
53
61
  * Set this value to offset the initial location of the list.
54
62
  * Warning: using this property will still run a render cycle at the scrollTop: 0 list window.
@@ -492,10 +500,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
492
500
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
493
501
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
494
502
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
495
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
503
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
504
+ * Called when the list starts/stops scrolling.
505
+ */
496
506
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
497
507
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
498
508
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
509
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
510
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
499
511
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
500
512
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
501
513
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -513,10 +525,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
513
525
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
514
526
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
515
527
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
516
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
528
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
529
+ * Called when the list starts/stops scrolling.
530
+ */
517
531
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
518
532
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
519
533
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
534
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
535
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
520
536
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
521
537
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
522
538
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -533,10 +549,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
533
549
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
534
550
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
535
551
  /**
552
+ * *The property accepts pixel values.*
553
+ *
536
554
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
537
555
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
538
556
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
539
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
557
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
558
+ *
540
559
  */
541
560
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
542
561
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -553,10 +572,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
553
572
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
554
573
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
555
574
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
556
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
575
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
576
+ * Called when the list starts/stops scrolling.
577
+ */
557
578
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
558
579
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
559
580
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
581
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
582
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
560
583
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
561
584
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
562
585
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -573,10 +596,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
573
596
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
574
597
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
575
598
  /**
599
+ * *The property accepts pixel values.*
600
+ *
576
601
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
577
602
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
578
603
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
579
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
604
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
605
+ *
580
606
  */
581
607
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
582
608
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -590,10 +616,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
590
616
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
591
617
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
592
618
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
593
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
619
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
620
+ * Called when the list starts/stops scrolling.
621
+ */
594
622
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
595
623
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
596
624
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
625
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
626
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
597
627
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
598
628
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
599
629
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -610,10 +640,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
610
640
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
611
641
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
612
642
  /**
643
+ * *The property accepts pixel values.*
644
+ *
613
645
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
614
646
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
615
647
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
616
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
648
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
649
+ *
617
650
  */
618
651
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
619
652
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -639,10 +672,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
639
672
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
640
673
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
641
674
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
642
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
675
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
676
+ * Called when the list starts/stops scrolling.
677
+ */
643
678
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
644
679
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
645
680
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
681
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
682
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
646
683
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
647
684
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
648
685
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -659,10 +696,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
659
696
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
660
697
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
661
698
  /**
699
+ * *The property accepts pixel values.*
700
+ *
662
701
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
663
702
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
664
703
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
665
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
704
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
705
+ *
666
706
  */
667
707
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
668
708
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -677,7 +717,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
677
717
  didMount: import("@virtuoso.dev/urx").Stream<boolean>;
678
718
  }]) => {
679
719
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
680
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
720
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
681
721
  }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
682
722
  scrollContainerState: import("@virtuoso.dev/urx").Stream<[number, number]>;
683
723
  scrollTop: import("@virtuoso.dev/urx").Stream<number>;
@@ -687,10 +727,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
687
727
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
688
728
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
689
729
  /**
730
+ * *The property accepts pixel values.*
731
+ *
690
732
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
691
733
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
692
734
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
693
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
735
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
736
+ *
694
737
  */
695
738
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
696
739
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -707,10 +750,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
707
750
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
708
751
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
709
752
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
710
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
753
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
754
+ * Called when the list starts/stops scrolling.
755
+ */
711
756
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
712
757
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
713
758
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
759
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
760
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
714
761
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
715
762
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
716
763
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -727,10 +774,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
727
774
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
728
775
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
729
776
  /**
777
+ * *The property accepts pixel values.*
778
+ *
730
779
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
731
780
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
732
781
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
733
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
782
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
783
+ *
734
784
  */
735
785
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
736
786
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -746,10 +796,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
746
796
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
747
797
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
748
798
  /**
799
+ * *The property accepts pixel values.*
800
+ *
749
801
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
750
802
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
751
803
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
752
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
804
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
805
+ *
753
806
  */
754
807
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
755
808
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -777,10 +830,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
777
830
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
778
831
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
779
832
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
780
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
833
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
834
+ * Called when the list starts/stops scrolling.
835
+ */
781
836
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
782
837
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
783
838
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
839
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
840
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
784
841
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
785
842
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
786
843
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -797,10 +854,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
797
854
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
798
855
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
799
856
  /**
857
+ * *The property accepts pixel values.*
858
+ *
800
859
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
801
860
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
802
861
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
803
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
862
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
863
+ *
804
864
  */
805
865
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
806
866
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -814,10 +874,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
814
874
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
815
875
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
816
876
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
817
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
877
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
878
+ * Called when the list starts/stops scrolling.
879
+ */
818
880
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
819
881
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
820
882
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
883
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
884
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
821
885
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
822
886
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
823
887
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -834,10 +898,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
834
898
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
835
899
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
836
900
  /**
901
+ * *The property accepts pixel values.*
902
+ *
837
903
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
838
904
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
839
905
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
840
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
906
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
907
+ *
841
908
  */
842
909
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
843
910
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -860,10 +927,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
860
927
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
861
928
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
862
929
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
863
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
930
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
931
+ * Called when the list starts/stops scrolling.
932
+ */
864
933
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
865
934
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
866
935
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
936
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
937
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
867
938
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
868
939
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
869
940
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -880,10 +951,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
880
951
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
881
952
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
882
953
  /**
954
+ * *The property accepts pixel values.*
955
+ *
883
956
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
884
957
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
885
958
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
886
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
959
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
960
+ *
887
961
  */
888
962
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
889
963
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -900,10 +974,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
900
974
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
901
975
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
902
976
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
903
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
977
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
978
+ * Called when the list starts/stops scrolling.
979
+ */
904
980
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
905
981
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
906
982
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
983
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
984
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
907
985
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
908
986
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
909
987
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -920,10 +998,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
920
998
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
921
999
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
922
1000
  /**
1001
+ * *The property accepts pixel values.*
1002
+ *
923
1003
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
924
1004
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
925
1005
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
926
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1006
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1007
+ *
927
1008
  */
928
1009
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
929
1010
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -937,10 +1018,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
937
1018
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
938
1019
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
939
1020
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
940
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
1021
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
1022
+ * Called when the list starts/stops scrolling.
1023
+ */
941
1024
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
942
1025
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
943
1026
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1027
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
1028
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
944
1029
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
945
1030
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
946
1031
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -957,10 +1042,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
957
1042
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
958
1043
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
959
1044
  /**
1045
+ * *The property accepts pixel values.*
1046
+ *
960
1047
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
961
1048
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
962
1049
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
963
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1050
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1051
+ *
964
1052
  */
965
1053
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
966
1054
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -986,10 +1074,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
986
1074
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
987
1075
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
988
1076
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
989
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
1077
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
1078
+ * Called when the list starts/stops scrolling.
1079
+ */
990
1080
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
991
1081
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
992
1082
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1083
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
1084
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
993
1085
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
994
1086
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
995
1087
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1006,10 +1098,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1006
1098
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1007
1099
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1008
1100
  /**
1101
+ * *The property accepts pixel values.*
1102
+ *
1009
1103
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1010
1104
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1011
1105
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1012
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1106
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1107
+ *
1013
1108
  */
1014
1109
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1015
1110
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1024,7 +1119,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1024
1119
  didMount: import("@virtuoso.dev/urx").Stream<boolean>;
1025
1120
  }]) => {
1026
1121
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
1027
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1122
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
1028
1123
  }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
1029
1124
  log: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").Log>;
1030
1125
  logLevel: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").LogLevel>;
@@ -1046,10 +1141,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1046
1141
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1047
1142
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1048
1143
  /**
1144
+ * *The property accepts pixel values.*
1145
+ *
1049
1146
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1050
1147
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1051
1148
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1052
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1149
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1150
+ *
1053
1151
  */
1054
1152
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1055
1153
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1060,10 +1158,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1060
1158
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1061
1159
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1062
1160
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1063
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
1161
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
1162
+ * Called when the list starts/stops scrolling.
1163
+ */
1064
1164
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1065
1165
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1066
1166
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1167
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
1168
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1067
1169
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1068
1170
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1069
1171
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1087,7 +1189,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1087
1189
  topListHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
1088
1190
  }, {
1089
1191
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
1090
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1192
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
1091
1193
  }, {
1092
1194
  propsReady: import("@virtuoso.dev/urx").StatefulStream<boolean>;
1093
1195
  didMount: import("@virtuoso.dev/urx").Stream<boolean>;
@@ -1103,10 +1205,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1103
1205
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1104
1206
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1105
1207
  /**
1208
+ * *The property accepts pixel values.*
1209
+ *
1106
1210
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1107
1211
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1108
1212
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1109
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1213
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1214
+ *
1110
1215
  */
1111
1216
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1112
1217
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1125,10 +1230,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1125
1230
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1126
1231
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1127
1232
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1128
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
1233
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
1234
+ * Called when the list starts/stops scrolling.
1235
+ */
1129
1236
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1130
1237
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1131
1238
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1239
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
1240
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1132
1241
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1133
1242
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1134
1243
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1146,10 +1255,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1146
1255
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1147
1256
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1148
1257
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1149
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
1258
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
1259
+ * Called when the list starts/stops scrolling.
1260
+ */
1150
1261
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1151
1262
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1152
1263
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1264
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
1265
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1153
1266
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1154
1267
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1155
1268
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1166,10 +1279,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1166
1279
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1167
1280
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1168
1281
  /**
1282
+ * *The property accepts pixel values.*
1283
+ *
1169
1284
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1170
1285
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1171
1286
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1172
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1287
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1288
+ *
1173
1289
  */
1174
1290
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1175
1291
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1180,10 +1296,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1180
1296
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1181
1297
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1182
1298
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1183
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
1299
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
1300
+ * Called when the list starts/stops scrolling.
1301
+ */
1184
1302
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1185
1303
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1186
1304
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1305
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
1306
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1187
1307
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1188
1308
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1189
1309
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1200,10 +1320,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1200
1320
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1201
1321
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1202
1322
  /**
1323
+ * *The property accepts pixel values.*
1324
+ *
1203
1325
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1204
1326
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1205
1327
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1206
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1328
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1329
+ *
1207
1330
  */
1208
1331
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1209
1332
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1222,10 +1345,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1222
1345
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1223
1346
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1224
1347
  /**
1348
+ * *The property accepts pixel values.*
1349
+ *
1225
1350
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1226
1351
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1227
1352
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1228
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1353
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1354
+ *
1229
1355
  */
1230
1356
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1231
1357
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1241,10 +1367,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1241
1367
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1242
1368
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1243
1369
  /**
1370
+ * *The property accepts pixel values.*
1371
+ *
1244
1372
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1245
1373
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1246
1374
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1247
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1375
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1376
+ *
1248
1377
  */
1249
1378
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1250
1379
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1268,10 +1397,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1268
1397
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1269
1398
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1270
1399
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1271
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
1400
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
1401
+ * Called when the list starts/stops scrolling.
1402
+ */
1272
1403
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1273
1404
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1274
1405
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1406
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
1407
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1275
1408
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1276
1409
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1277
1410
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1288,10 +1421,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1288
1421
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1289
1422
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1290
1423
  /**
1424
+ * *The property accepts pixel values.*
1425
+ *
1291
1426
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1292
1427
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1293
1428
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1294
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1429
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1430
+ *
1295
1431
  */
1296
1432
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1297
1433
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1308,10 +1444,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1308
1444
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1309
1445
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1310
1446
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1311
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
1447
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
1448
+ * Called when the list starts/stops scrolling.
1449
+ */
1312
1450
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1313
1451
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1314
1452
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1453
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
1454
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1315
1455
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1316
1456
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1317
1457
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1328,10 +1468,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1328
1468
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1329
1469
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1330
1470
  /**
1471
+ * *The property accepts pixel values.*
1472
+ *
1331
1473
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1332
1474
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1333
1475
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1334
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1476
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1477
+ *
1335
1478
  */
1336
1479
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1337
1480
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1345,10 +1488,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1345
1488
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1346
1489
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1347
1490
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1348
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
1491
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
1492
+ * Called when the list starts/stops scrolling.
1493
+ */
1349
1494
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1350
1495
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1351
1496
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1497
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
1498
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1352
1499
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1353
1500
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1354
1501
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1365,10 +1512,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1365
1512
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1366
1513
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1367
1514
  /**
1515
+ * *The property accepts pixel values.*
1516
+ *
1368
1517
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1369
1518
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1370
1519
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1371
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1520
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1521
+ *
1372
1522
  */
1373
1523
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1374
1524
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1394,10 +1544,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1394
1544
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1395
1545
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1396
1546
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1397
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
1547
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
1548
+ * Called when the list starts/stops scrolling.
1549
+ */
1398
1550
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1399
1551
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1400
1552
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1553
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
1554
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1401
1555
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1402
1556
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1403
1557
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1414,10 +1568,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1414
1568
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1415
1569
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1416
1570
  /**
1571
+ * *The property accepts pixel values.*
1572
+ *
1417
1573
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1418
1574
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1419
1575
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1420
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1576
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1577
+ *
1421
1578
  */
1422
1579
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1423
1580
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1432,7 +1589,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1432
1589
  didMount: import("@virtuoso.dev/urx").Stream<boolean>;
1433
1590
  }]) => {
1434
1591
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
1435
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1592
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
1436
1593
  }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
1437
1594
  log: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").Log>;
1438
1595
  logLevel: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").LogLevel>;
@@ -1443,10 +1600,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1443
1600
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1444
1601
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1445
1602
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1446
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
1603
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
1604
+ * Called when the list starts/stops scrolling.
1605
+ */
1447
1606
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1448
1607
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1449
1608
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1609
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
1610
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1450
1611
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1451
1612
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1452
1613
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1463,10 +1624,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1463
1624
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1464
1625
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1465
1626
  /**
1627
+ * *The property accepts pixel values.*
1628
+ *
1466
1629
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1467
1630
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1468
1631
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1469
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1632
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1633
+ *
1470
1634
  */
1471
1635
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1472
1636
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1480,10 +1644,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1480
1644
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1481
1645
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1482
1646
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1483
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
1647
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
1648
+ * Called when the list starts/stops scrolling.
1649
+ */
1484
1650
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1485
1651
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1486
1652
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1653
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
1654
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1487
1655
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1488
1656
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1489
1657
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1500,10 +1668,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1500
1668
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1501
1669
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1502
1670
  /**
1671
+ * *The property accepts pixel values.*
1672
+ *
1503
1673
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1504
1674
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1505
1675
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1506
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1676
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1677
+ *
1507
1678
  */
1508
1679
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1509
1680
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1525,10 +1696,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1525
1696
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1526
1697
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1527
1698
  /**
1699
+ * *The property accepts pixel values.*
1700
+ *
1528
1701
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1529
1702
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1530
1703
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1531
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1704
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1705
+ *
1532
1706
  */
1533
1707
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1534
1708
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1544,10 +1718,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1544
1718
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1545
1719
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1546
1720
  /**
1721
+ * *The property accepts pixel values.*
1722
+ *
1547
1723
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1548
1724
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1549
1725
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1550
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1726
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1727
+ *
1551
1728
  */
1552
1729
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1553
1730
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1578,10 +1755,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1578
1755
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1579
1756
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1580
1757
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1581
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
1758
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
1759
+ * Called when the list starts/stops scrolling.
1760
+ */
1582
1761
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1583
1762
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1584
1763
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1764
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
1765
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1585
1766
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1586
1767
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1587
1768
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1601,7 +1782,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1601
1782
  visibleRange: import("@virtuoso.dev/urx").StatefulStream<import("./sizeRangeSystem").NumberTuple>;
1602
1783
  }, {
1603
1784
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
1604
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1785
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
1605
1786
  }, {
1606
1787
  scrollToIndex: import("@virtuoso.dev/urx").Stream<import("./scrollToIndexSystem").IndexLocation>;
1607
1788
  topListHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -1646,10 +1827,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1646
1827
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1647
1828
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1648
1829
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1649
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
1830
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
1831
+ * Called when the list starts/stops scrolling.
1832
+ */
1650
1833
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1651
1834
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1652
1835
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1836
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
1837
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1653
1838
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1654
1839
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1655
1840
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1666,10 +1851,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1666
1851
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1667
1852
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1668
1853
  /**
1854
+ * *The property accepts pixel values.*
1855
+ *
1669
1856
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1670
1857
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1671
1858
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1672
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1859
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1860
+ *
1673
1861
  */
1674
1862
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1675
1863
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1683,10 +1871,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1683
1871
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1684
1872
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1685
1873
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1686
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
1874
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
1875
+ * Called when the list starts/stops scrolling.
1876
+ */
1687
1877
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1688
1878
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1689
1879
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1880
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
1881
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1690
1882
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1691
1883
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1692
1884
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1703,10 +1895,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1703
1895
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1704
1896
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1705
1897
  /**
1898
+ * *The property accepts pixel values.*
1899
+ *
1706
1900
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1707
1901
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1708
1902
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1709
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1903
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1904
+ *
1710
1905
  */
1711
1906
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1712
1907
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1728,10 +1923,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1728
1923
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1729
1924
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1730
1925
  /**
1926
+ * *The property accepts pixel values.*
1927
+ *
1731
1928
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1732
1929
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1733
1930
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1734
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1931
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1932
+ *
1735
1933
  */
1736
1934
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1737
1935
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1747,10 +1945,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1747
1945
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1748
1946
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1749
1947
  /**
1948
+ * *The property accepts pixel values.*
1949
+ *
1750
1950
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1751
1951
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1752
1952
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1753
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1953
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1954
+ *
1754
1955
  */
1755
1956
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1756
1957
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1766,10 +1967,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1766
1967
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1767
1968
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1768
1969
  /**
1970
+ * *The property accepts pixel values.*
1971
+ *
1769
1972
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1770
1973
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1771
1974
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1772
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
1975
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
1976
+ *
1773
1977
  */
1774
1978
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1775
1979
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1797,10 +2001,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1797
2001
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1798
2002
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1799
2003
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1800
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2004
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2005
+ * Called when the list starts/stops scrolling.
2006
+ */
1801
2007
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1802
2008
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1803
2009
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2010
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2011
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1804
2012
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1805
2013
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1806
2014
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1818,10 +2026,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1818
2026
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1819
2027
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1820
2028
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1821
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2029
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2030
+ * Called when the list starts/stops scrolling.
2031
+ */
1822
2032
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1823
2033
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1824
2034
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2035
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2036
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1825
2037
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1826
2038
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1827
2039
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1838,10 +2050,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1838
2050
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1839
2051
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1840
2052
  /**
2053
+ * *The property accepts pixel values.*
2054
+ *
1841
2055
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1842
2056
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1843
2057
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1844
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2058
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2059
+ *
1845
2060
  */
1846
2061
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1847
2062
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1852,10 +2067,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1852
2067
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1853
2068
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1854
2069
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1855
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2070
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2071
+ * Called when the list starts/stops scrolling.
2072
+ */
1856
2073
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1857
2074
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1858
2075
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2076
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2077
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1859
2078
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1860
2079
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1861
2080
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1872,10 +2091,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1872
2091
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1873
2092
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1874
2093
  /**
2094
+ * *The property accepts pixel values.*
2095
+ *
1875
2096
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1876
2097
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1877
2098
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1878
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2099
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2100
+ *
1879
2101
  */
1880
2102
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1881
2103
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1894,10 +2116,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1894
2116
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1895
2117
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1896
2118
  /**
2119
+ * *The property accepts pixel values.*
2120
+ *
1897
2121
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1898
2122
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1899
2123
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1900
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2124
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2125
+ *
1901
2126
  */
1902
2127
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1903
2128
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1913,10 +2138,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1913
2138
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1914
2139
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1915
2140
  /**
2141
+ * *The property accepts pixel values.*
2142
+ *
1916
2143
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1917
2144
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1918
2145
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1919
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2146
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2147
+ *
1920
2148
  */
1921
2149
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1922
2150
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1940,10 +2168,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1940
2168
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1941
2169
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1942
2170
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1943
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2171
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2172
+ * Called when the list starts/stops scrolling.
2173
+ */
1944
2174
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1945
2175
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1946
2176
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2177
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2178
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1947
2179
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1948
2180
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1949
2181
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -1960,10 +2192,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1960
2192
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
1961
2193
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
1962
2194
  /**
2195
+ * *The property accepts pixel values.*
2196
+ *
1963
2197
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
1964
2198
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
1965
2199
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
1966
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2200
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2201
+ *
1967
2202
  */
1968
2203
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
1969
2204
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -1980,10 +2215,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
1980
2215
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
1981
2216
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
1982
2217
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
1983
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2218
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2219
+ * Called when the list starts/stops scrolling.
2220
+ */
1984
2221
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1985
2222
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
1986
2223
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2224
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2225
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
1987
2226
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
1988
2227
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
1989
2228
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2000,10 +2239,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2000
2239
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2001
2240
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2002
2241
  /**
2242
+ * *The property accepts pixel values.*
2243
+ *
2003
2244
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2004
2245
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2005
2246
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2006
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2247
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2248
+ *
2007
2249
  */
2008
2250
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2009
2251
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2017,10 +2259,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2017
2259
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2018
2260
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2019
2261
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2020
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2262
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2263
+ * Called when the list starts/stops scrolling.
2264
+ */
2021
2265
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2022
2266
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2023
2267
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2268
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2269
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2024
2270
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2025
2271
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2026
2272
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2037,10 +2283,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2037
2283
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2038
2284
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2039
2285
  /**
2286
+ * *The property accepts pixel values.*
2287
+ *
2040
2288
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2041
2289
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2042
2290
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2043
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2291
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2292
+ *
2044
2293
  */
2045
2294
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2046
2295
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2066,10 +2315,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2066
2315
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2067
2316
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2068
2317
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2069
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2318
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2319
+ * Called when the list starts/stops scrolling.
2320
+ */
2070
2321
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2071
2322
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2072
2323
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2324
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2325
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2073
2326
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2074
2327
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2075
2328
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2086,10 +2339,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2086
2339
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2087
2340
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2088
2341
  /**
2342
+ * *The property accepts pixel values.*
2343
+ *
2089
2344
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2090
2345
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2091
2346
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2092
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2347
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2348
+ *
2093
2349
  */
2094
2350
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2095
2351
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2104,7 +2360,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2104
2360
  didMount: import("@virtuoso.dev/urx").Stream<boolean>;
2105
2361
  }]) => {
2106
2362
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
2107
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2363
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
2108
2364
  }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
2109
2365
  log: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").Log>;
2110
2366
  logLevel: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").LogLevel>;
@@ -2115,10 +2371,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2115
2371
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2116
2372
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2117
2373
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2118
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2374
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2375
+ * Called when the list starts/stops scrolling.
2376
+ */
2119
2377
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2120
2378
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2121
2379
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2380
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2381
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2122
2382
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2123
2383
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2124
2384
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2135,10 +2395,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2135
2395
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2136
2396
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2137
2397
  /**
2398
+ * *The property accepts pixel values.*
2399
+ *
2138
2400
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2139
2401
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2140
2402
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2141
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2403
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2404
+ *
2142
2405
  */
2143
2406
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2144
2407
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2152,10 +2415,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2152
2415
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2153
2416
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2154
2417
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2155
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2418
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2419
+ * Called when the list starts/stops scrolling.
2420
+ */
2156
2421
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2157
2422
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2158
2423
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2424
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2425
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2159
2426
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2160
2427
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2161
2428
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2172,10 +2439,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2172
2439
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2173
2440
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2174
2441
  /**
2442
+ * *The property accepts pixel values.*
2443
+ *
2175
2444
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2176
2445
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2177
2446
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2178
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2447
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2448
+ *
2179
2449
  */
2180
2450
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2181
2451
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2197,10 +2467,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2197
2467
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2198
2468
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2199
2469
  /**
2470
+ * *The property accepts pixel values.*
2471
+ *
2200
2472
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2201
2473
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2202
2474
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2203
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2475
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2476
+ *
2204
2477
  */
2205
2478
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2206
2479
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2216,10 +2489,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2216
2489
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2217
2490
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2218
2491
  /**
2492
+ * *The property accepts pixel values.*
2493
+ *
2219
2494
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2220
2495
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2221
2496
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2222
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2497
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2498
+ *
2223
2499
  */
2224
2500
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2225
2501
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2250,10 +2526,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2250
2526
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2251
2527
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2252
2528
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2253
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2529
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2530
+ * Called when the list starts/stops scrolling.
2531
+ */
2254
2532
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2255
2533
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2256
2534
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2535
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2536
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2257
2537
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2258
2538
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2259
2539
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2273,7 +2553,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2273
2553
  visibleRange: import("@virtuoso.dev/urx").StatefulStream<import("./sizeRangeSystem").NumberTuple>;
2274
2554
  }, {
2275
2555
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
2276
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2556
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
2277
2557
  }, {
2278
2558
  scrollToIndex: import("@virtuoso.dev/urx").Stream<import("./scrollToIndexSystem").IndexLocation>;
2279
2559
  topListHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2318,10 +2598,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2318
2598
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2319
2599
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2320
2600
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2321
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2601
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2602
+ * Called when the list starts/stops scrolling.
2603
+ */
2322
2604
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2323
2605
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2324
2606
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2607
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2608
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2325
2609
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2326
2610
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2327
2611
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2332,7 +2616,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2332
2616
  }>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
2333
2617
  log: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").Log>;
2334
2618
  logLevel: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").LogLevel>;
2335
- }>], ([{ scrollBy, scrollTop, deviation, scrollingInProgress }, { isScrolling, isAtBottom, atBottomState, scrollDirection, lastJumpDueToItemResize }, { listState }, { beforeUnshiftWith, sizes }, { log },]: [{
2619
+ }>], ([{ scrollBy, scrollTop, deviation, scrollingInProgress }, { isScrolling, isAtBottom, atBottomState, scrollDirection, lastJumpDueToItemResize }, { listState }, { beforeUnshiftWith, shiftWithOffset, sizes }, { log },]: [{
2336
2620
  scrollContainerState: import("@virtuoso.dev/urx").Stream<[number, number]>;
2337
2621
  scrollTop: import("@virtuoso.dev/urx").Stream<number>;
2338
2622
  viewportHeight: import("@virtuoso.dev/urx").Stream<number>;
@@ -2341,10 +2625,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2341
2625
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2342
2626
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2343
2627
  /**
2628
+ * *The property accepts pixel values.*
2629
+ *
2344
2630
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2345
2631
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2346
2632
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2347
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2633
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2634
+ *
2348
2635
  */
2349
2636
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2350
2637
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2383,10 +2670,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2383
2670
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2384
2671
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2385
2672
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2386
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2673
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2674
+ * Called when the list starts/stops scrolling.
2675
+ */
2387
2676
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2388
2677
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2389
2678
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2679
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2680
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2390
2681
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2391
2682
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2392
2683
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2409,10 +2700,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2409
2700
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2410
2701
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2411
2702
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2412
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2703
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2704
+ * Called when the list starts/stops scrolling.
2705
+ */
2413
2706
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2414
2707
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2415
2708
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2709
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2710
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2416
2711
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2417
2712
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2418
2713
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2430,10 +2725,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2430
2725
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2431
2726
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2432
2727
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2433
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2728
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2729
+ * Called when the list starts/stops scrolling.
2730
+ */
2434
2731
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2435
2732
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2436
2733
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2734
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2735
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2437
2736
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2438
2737
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2439
2738
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2450,10 +2749,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2450
2749
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2451
2750
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2452
2751
  /**
2752
+ * *The property accepts pixel values.*
2753
+ *
2453
2754
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2454
2755
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2455
2756
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2456
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2757
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2758
+ *
2457
2759
  */
2458
2760
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2459
2761
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2464,10 +2766,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2464
2766
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2465
2767
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2466
2768
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2467
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2769
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2770
+ * Called when the list starts/stops scrolling.
2771
+ */
2468
2772
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2469
2773
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2470
2774
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2775
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2776
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2471
2777
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2472
2778
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2473
2779
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2484,10 +2790,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2484
2790
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2485
2791
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2486
2792
  /**
2793
+ * *The property accepts pixel values.*
2794
+ *
2487
2795
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2488
2796
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2489
2797
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2490
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2798
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2799
+ *
2491
2800
  */
2492
2801
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2493
2802
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2506,10 +2815,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2506
2815
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2507
2816
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2508
2817
  /**
2818
+ * *The property accepts pixel values.*
2819
+ *
2509
2820
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2510
2821
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2511
2822
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2512
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2823
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2824
+ *
2513
2825
  */
2514
2826
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2515
2827
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2525,10 +2837,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2525
2837
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2526
2838
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2527
2839
  /**
2840
+ * *The property accepts pixel values.*
2841
+ *
2528
2842
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2529
2843
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2530
2844
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2531
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2845
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2846
+ *
2532
2847
  */
2533
2848
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2534
2849
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2552,10 +2867,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2552
2867
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2553
2868
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2554
2869
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2555
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2870
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2871
+ * Called when the list starts/stops scrolling.
2872
+ */
2556
2873
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2557
2874
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2558
2875
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2876
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2877
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2559
2878
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2560
2879
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2561
2880
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2572,10 +2891,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2572
2891
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2573
2892
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2574
2893
  /**
2894
+ * *The property accepts pixel values.*
2895
+ *
2575
2896
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2576
2897
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2577
2898
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2578
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2899
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2900
+ *
2579
2901
  */
2580
2902
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2581
2903
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2592,10 +2914,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2592
2914
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2593
2915
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2594
2916
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2595
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2917
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2918
+ * Called when the list starts/stops scrolling.
2919
+ */
2596
2920
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2597
2921
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2598
2922
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2923
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2924
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2599
2925
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2600
2926
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2601
2927
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2612,10 +2938,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2612
2938
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2613
2939
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2614
2940
  /**
2941
+ * *The property accepts pixel values.*
2942
+ *
2615
2943
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2616
2944
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2617
2945
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2618
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2946
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2947
+ *
2619
2948
  */
2620
2949
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2621
2950
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2629,10 +2958,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2629
2958
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2630
2959
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2631
2960
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2632
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
2961
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
2962
+ * Called when the list starts/stops scrolling.
2963
+ */
2633
2964
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2634
2965
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2635
2966
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2967
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
2968
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2636
2969
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2637
2970
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2638
2971
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2649,10 +2982,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2649
2982
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2650
2983
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2651
2984
  /**
2985
+ * *The property accepts pixel values.*
2986
+ *
2652
2987
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2653
2988
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2654
2989
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2655
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
2990
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
2991
+ *
2656
2992
  */
2657
2993
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2658
2994
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2678,10 +3014,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2678
3014
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2679
3015
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2680
3016
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2681
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
3017
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
3018
+ * Called when the list starts/stops scrolling.
3019
+ */
2682
3020
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2683
3021
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2684
3022
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3023
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
3024
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2685
3025
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2686
3026
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2687
3027
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2698,10 +3038,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2698
3038
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2699
3039
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2700
3040
  /**
3041
+ * *The property accepts pixel values.*
3042
+ *
2701
3043
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2702
3044
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2703
3045
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2704
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3046
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3047
+ *
2705
3048
  */
2706
3049
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2707
3050
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2716,7 +3059,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2716
3059
  didMount: import("@virtuoso.dev/urx").Stream<boolean>;
2717
3060
  }]) => {
2718
3061
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
2719
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3062
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
2720
3063
  }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
2721
3064
  log: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").Log>;
2722
3065
  logLevel: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").LogLevel>;
@@ -2727,10 +3070,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2727
3070
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2728
3071
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2729
3072
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2730
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
3073
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
3074
+ * Called when the list starts/stops scrolling.
3075
+ */
2731
3076
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2732
3077
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2733
3078
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3079
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
3080
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2734
3081
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2735
3082
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2736
3083
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2747,10 +3094,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2747
3094
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2748
3095
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2749
3096
  /**
3097
+ * *The property accepts pixel values.*
3098
+ *
2750
3099
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2751
3100
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2752
3101
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2753
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3102
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3103
+ *
2754
3104
  */
2755
3105
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2756
3106
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2764,10 +3114,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2764
3114
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2765
3115
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2766
3116
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2767
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
3117
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
3118
+ * Called when the list starts/stops scrolling.
3119
+ */
2768
3120
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2769
3121
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2770
3122
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3123
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
3124
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2771
3125
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2772
3126
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2773
3127
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2784,10 +3138,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2784
3138
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2785
3139
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2786
3140
  /**
3141
+ * *The property accepts pixel values.*
3142
+ *
2787
3143
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2788
3144
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2789
3145
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2790
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3146
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3147
+ *
2791
3148
  */
2792
3149
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2793
3150
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2809,10 +3166,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2809
3166
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2810
3167
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2811
3168
  /**
3169
+ * *The property accepts pixel values.*
3170
+ *
2812
3171
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2813
3172
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2814
3173
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2815
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3174
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3175
+ *
2816
3176
  */
2817
3177
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2818
3178
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2828,10 +3188,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2828
3188
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2829
3189
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2830
3190
  /**
3191
+ * *The property accepts pixel values.*
3192
+ *
2831
3193
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2832
3194
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2833
3195
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2834
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3196
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3197
+ *
2835
3198
  */
2836
3199
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2837
3200
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2862,10 +3225,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2862
3225
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2863
3226
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2864
3227
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2865
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
3228
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
3229
+ * Called when the list starts/stops scrolling.
3230
+ */
2866
3231
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2867
3232
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2868
3233
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3234
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
3235
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2869
3236
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2870
3237
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2871
3238
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2885,7 +3252,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2885
3252
  visibleRange: import("@virtuoso.dev/urx").StatefulStream<import("./sizeRangeSystem").NumberTuple>;
2886
3253
  }, {
2887
3254
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
2888
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3255
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
2889
3256
  }, {
2890
3257
  scrollToIndex: import("@virtuoso.dev/urx").Stream<import("./scrollToIndexSystem").IndexLocation>;
2891
3258
  topListHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -2949,10 +3316,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2949
3316
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2950
3317
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2951
3318
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2952
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
3319
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
3320
+ * Called when the list starts/stops scrolling.
3321
+ */
2953
3322
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2954
3323
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2955
3324
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3325
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
3326
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2956
3327
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2957
3328
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2958
3329
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -2969,10 +3340,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2969
3340
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
2970
3341
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
2971
3342
  /**
3343
+ * *The property accepts pixel values.*
3344
+ *
2972
3345
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
2973
3346
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
2974
3347
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
2975
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3348
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3349
+ *
2976
3350
  */
2977
3351
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
2978
3352
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -2983,10 +3357,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
2983
3357
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
2984
3358
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
2985
3359
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
2986
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
3360
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
3361
+ * Called when the list starts/stops scrolling.
3362
+ */
2987
3363
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2988
3364
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
2989
3365
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3366
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
3367
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
2990
3368
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
2991
3369
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
2992
3370
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3003,10 +3381,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3003
3381
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3004
3382
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3005
3383
  /**
3384
+ * *The property accepts pixel values.*
3385
+ *
3006
3386
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3007
3387
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3008
3388
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3009
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3389
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3390
+ *
3010
3391
  */
3011
3392
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3012
3393
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3025,10 +3406,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3025
3406
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3026
3407
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3027
3408
  /**
3409
+ * *The property accepts pixel values.*
3410
+ *
3028
3411
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3029
3412
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3030
3413
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3031
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3414
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3415
+ *
3032
3416
  */
3033
3417
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3034
3418
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3044,10 +3428,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3044
3428
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3045
3429
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3046
3430
  /**
3431
+ * *The property accepts pixel values.*
3432
+ *
3047
3433
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3048
3434
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3049
3435
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3050
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3436
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3437
+ *
3051
3438
  */
3052
3439
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3053
3440
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3071,10 +3458,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3071
3458
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3072
3459
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3073
3460
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3074
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
3461
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
3462
+ * Called when the list starts/stops scrolling.
3463
+ */
3075
3464
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3076
3465
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3077
3466
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3467
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
3468
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3078
3469
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3079
3470
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3080
3471
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3092,10 +3483,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3092
3483
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3093
3484
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3094
3485
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3095
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
3486
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
3487
+ * Called when the list starts/stops scrolling.
3488
+ */
3096
3489
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3097
3490
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3098
3491
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3492
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
3493
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3099
3494
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3100
3495
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3101
3496
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3113,10 +3508,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3113
3508
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3114
3509
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3115
3510
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3116
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
3511
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
3512
+ * Called when the list starts/stops scrolling.
3513
+ */
3117
3514
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3118
3515
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3119
3516
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3517
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
3518
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3120
3519
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3121
3520
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3122
3521
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3133,10 +3532,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3133
3532
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3134
3533
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3135
3534
  /**
3535
+ * *The property accepts pixel values.*
3536
+ *
3136
3537
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3137
3538
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3138
3539
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3139
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3540
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3541
+ *
3140
3542
  */
3141
3543
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3142
3544
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3147,10 +3549,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3147
3549
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3148
3550
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3149
3551
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3150
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
3552
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
3553
+ * Called when the list starts/stops scrolling.
3554
+ */
3151
3555
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3152
3556
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3153
3557
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3558
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
3559
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3154
3560
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3155
3561
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3156
3562
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3167,10 +3573,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3167
3573
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3168
3574
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3169
3575
  /**
3576
+ * *The property accepts pixel values.*
3577
+ *
3170
3578
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3171
3579
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3172
3580
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3173
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3581
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3582
+ *
3174
3583
  */
3175
3584
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3176
3585
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3189,10 +3598,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3189
3598
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3190
3599
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3191
3600
  /**
3601
+ * *The property accepts pixel values.*
3602
+ *
3192
3603
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3193
3604
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3194
3605
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3195
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3606
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3607
+ *
3196
3608
  */
3197
3609
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3198
3610
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3208,10 +3620,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3208
3620
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3209
3621
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3210
3622
  /**
3623
+ * *The property accepts pixel values.*
3624
+ *
3211
3625
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3212
3626
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3213
3627
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3214
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3628
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3629
+ *
3215
3630
  */
3216
3631
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3217
3632
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3235,10 +3650,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3235
3650
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3236
3651
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3237
3652
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3238
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
3653
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
3654
+ * Called when the list starts/stops scrolling.
3655
+ */
3239
3656
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3240
3657
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3241
3658
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3659
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
3660
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3242
3661
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3243
3662
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3244
3663
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3255,10 +3674,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3255
3674
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3256
3675
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3257
3676
  /**
3677
+ * *The property accepts pixel values.*
3678
+ *
3258
3679
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3259
3680
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3260
3681
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3261
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3682
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3683
+ *
3262
3684
  */
3263
3685
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3264
3686
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3275,10 +3697,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3275
3697
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3276
3698
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3277
3699
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3278
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
3700
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
3701
+ * Called when the list starts/stops scrolling.
3702
+ */
3279
3703
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3280
3704
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3281
3705
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3706
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
3707
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3282
3708
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3283
3709
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3284
3710
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3295,10 +3721,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3295
3721
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3296
3722
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3297
3723
  /**
3724
+ * *The property accepts pixel values.*
3725
+ *
3298
3726
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3299
3727
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3300
3728
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3301
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3729
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3730
+ *
3302
3731
  */
3303
3732
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3304
3733
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3312,10 +3741,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3312
3741
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3313
3742
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3314
3743
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3315
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
3744
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
3745
+ * Called when the list starts/stops scrolling.
3746
+ */
3316
3747
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3317
3748
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3318
3749
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3750
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
3751
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3319
3752
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3320
3753
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3321
3754
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3332,10 +3765,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3332
3765
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3333
3766
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3334
3767
  /**
3768
+ * *The property accepts pixel values.*
3769
+ *
3335
3770
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3336
3771
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3337
3772
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3338
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3773
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3774
+ *
3339
3775
  */
3340
3776
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3341
3777
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3361,10 +3797,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3361
3797
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3362
3798
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3363
3799
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3364
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
3800
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
3801
+ * Called when the list starts/stops scrolling.
3802
+ */
3365
3803
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3366
3804
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3367
3805
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3806
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
3807
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3368
3808
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3369
3809
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3370
3810
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3381,10 +3821,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3381
3821
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3382
3822
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3383
3823
  /**
3824
+ * *The property accepts pixel values.*
3825
+ *
3384
3826
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3385
3827
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3386
3828
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3387
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3829
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3830
+ *
3388
3831
  */
3389
3832
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3390
3833
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3399,7 +3842,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3399
3842
  didMount: import("@virtuoso.dev/urx").Stream<boolean>;
3400
3843
  }]) => {
3401
3844
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
3402
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3845
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
3403
3846
  }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
3404
3847
  log: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").Log>;
3405
3848
  logLevel: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").LogLevel>;
@@ -3410,10 +3853,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3410
3853
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3411
3854
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3412
3855
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3413
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
3856
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
3857
+ * Called when the list starts/stops scrolling.
3858
+ */
3414
3859
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3415
3860
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3416
3861
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3862
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
3863
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3417
3864
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3418
3865
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3419
3866
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3430,10 +3877,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3430
3877
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3431
3878
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3432
3879
  /**
3880
+ * *The property accepts pixel values.*
3881
+ *
3433
3882
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3434
3883
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3435
3884
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3436
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3885
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3886
+ *
3437
3887
  */
3438
3888
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3439
3889
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3447,10 +3897,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3447
3897
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3448
3898
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3449
3899
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3450
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
3900
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
3901
+ * Called when the list starts/stops scrolling.
3902
+ */
3451
3903
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3452
3904
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3453
3905
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3906
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
3907
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3454
3908
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3455
3909
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3456
3910
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3467,10 +3921,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3467
3921
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3468
3922
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3469
3923
  /**
3924
+ * *The property accepts pixel values.*
3925
+ *
3470
3926
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3471
3927
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3472
3928
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3473
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3929
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3930
+ *
3474
3931
  */
3475
3932
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3476
3933
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3492,10 +3949,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3492
3949
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3493
3950
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3494
3951
  /**
3952
+ * *The property accepts pixel values.*
3953
+ *
3495
3954
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3496
3955
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3497
3956
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3498
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3957
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3958
+ *
3499
3959
  */
3500
3960
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3501
3961
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3511,10 +3971,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3511
3971
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3512
3972
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3513
3973
  /**
3974
+ * *The property accepts pixel values.*
3975
+ *
3514
3976
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3515
3977
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3516
3978
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3517
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
3979
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
3980
+ *
3518
3981
  */
3519
3982
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3520
3983
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3545,10 +4008,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3545
4008
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3546
4009
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3547
4010
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3548
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
4011
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
4012
+ * Called when the list starts/stops scrolling.
4013
+ */
3549
4014
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3550
4015
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3551
4016
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4017
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
4018
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3552
4019
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3553
4020
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3554
4021
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3568,7 +4035,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3568
4035
  visibleRange: import("@virtuoso.dev/urx").StatefulStream<import("./sizeRangeSystem").NumberTuple>;
3569
4036
  }, {
3570
4037
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
3571
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4038
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
3572
4039
  }, {
3573
4040
  scrollToIndex: import("@virtuoso.dev/urx").Stream<import("./scrollToIndexSystem").IndexLocation>;
3574
4041
  topListHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -3616,10 +4083,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3616
4083
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3617
4084
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3618
4085
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3619
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
4086
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
4087
+ * Called when the list starts/stops scrolling.
4088
+ */
3620
4089
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3621
4090
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3622
4091
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4092
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
4093
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3623
4094
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3624
4095
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3625
4096
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3667,10 +4138,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3667
4138
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3668
4139
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3669
4140
  /**
4141
+ * *The property accepts pixel values.*
4142
+ *
3670
4143
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3671
4144
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3672
4145
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3673
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4146
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4147
+ *
3674
4148
  */
3675
4149
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3676
4150
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3686,10 +4160,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3686
4160
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3687
4161
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3688
4162
  /**
4163
+ * *The property accepts pixel values.*
4164
+ *
3689
4165
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3690
4166
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3691
4167
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3692
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4168
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4169
+ *
3693
4170
  */
3694
4171
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3695
4172
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3732,10 +4209,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3732
4209
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3733
4210
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3734
4211
  /**
4212
+ * *The property accepts pixel values.*
4213
+ *
3735
4214
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3736
4215
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3737
4216
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3738
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4217
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4218
+ *
3739
4219
  */
3740
4220
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3741
4221
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3752,10 +4232,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3752
4232
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3753
4233
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3754
4234
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3755
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
4235
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
4236
+ * Called when the list starts/stops scrolling.
4237
+ */
3756
4238
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3757
4239
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3758
4240
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4241
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
4242
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3759
4243
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3760
4244
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3761
4245
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3773,10 +4257,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3773
4257
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3774
4258
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3775
4259
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3776
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
4260
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
4261
+ * Called when the list starts/stops scrolling.
4262
+ */
3777
4263
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3778
4264
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3779
4265
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4266
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
4267
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3780
4268
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3781
4269
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3782
4270
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3793,10 +4281,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3793
4281
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3794
4282
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3795
4283
  /**
4284
+ * *The property accepts pixel values.*
4285
+ *
3796
4286
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3797
4287
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3798
4288
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3799
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4289
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4290
+ *
3800
4291
  */
3801
4292
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3802
4293
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3807,10 +4298,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3807
4298
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3808
4299
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3809
4300
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3810
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
4301
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
4302
+ * Called when the list starts/stops scrolling.
4303
+ */
3811
4304
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3812
4305
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3813
4306
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4307
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
4308
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3814
4309
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3815
4310
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3816
4311
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3827,10 +4322,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3827
4322
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3828
4323
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3829
4324
  /**
4325
+ * *The property accepts pixel values.*
4326
+ *
3830
4327
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3831
4328
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3832
4329
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3833
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4330
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4331
+ *
3834
4332
  */
3835
4333
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3836
4334
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3849,10 +4347,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3849
4347
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3850
4348
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3851
4349
  /**
4350
+ * *The property accepts pixel values.*
4351
+ *
3852
4352
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3853
4353
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3854
4354
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3855
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4355
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4356
+ *
3856
4357
  */
3857
4358
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3858
4359
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3868,10 +4369,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3868
4369
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3869
4370
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3870
4371
  /**
4372
+ * *The property accepts pixel values.*
4373
+ *
3871
4374
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3872
4375
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3873
4376
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3874
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4377
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4378
+ *
3875
4379
  */
3876
4380
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3877
4381
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3895,10 +4399,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3895
4399
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3896
4400
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3897
4401
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3898
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
4402
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
4403
+ * Called when the list starts/stops scrolling.
4404
+ */
3899
4405
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3900
4406
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3901
4407
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4408
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
4409
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3902
4410
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3903
4411
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3904
4412
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3915,10 +4423,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3915
4423
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3916
4424
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3917
4425
  /**
4426
+ * *The property accepts pixel values.*
4427
+ *
3918
4428
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3919
4429
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3920
4430
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3921
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4431
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4432
+ *
3922
4433
  */
3923
4434
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3924
4435
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3935,10 +4446,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3935
4446
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3936
4447
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3937
4448
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3938
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
4449
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
4450
+ * Called when the list starts/stops scrolling.
4451
+ */
3939
4452
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3940
4453
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3941
4454
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4455
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
4456
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3942
4457
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3943
4458
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3944
4459
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3955,10 +4470,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3955
4470
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3956
4471
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3957
4472
  /**
4473
+ * *The property accepts pixel values.*
4474
+ *
3958
4475
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3959
4476
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3960
4477
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3961
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4478
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4479
+ *
3962
4480
  */
3963
4481
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
3964
4482
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -3972,10 +4490,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3972
4490
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
3973
4491
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
3974
4492
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
3975
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
4493
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
4494
+ * Called when the list starts/stops scrolling.
4495
+ */
3976
4496
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3977
4497
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
3978
4498
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4499
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
4500
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
3979
4501
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
3980
4502
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
3981
4503
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -3992,10 +4514,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
3992
4514
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
3993
4515
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
3994
4516
  /**
4517
+ * *The property accepts pixel values.*
4518
+ *
3995
4519
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
3996
4520
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
3997
4521
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
3998
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4522
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4523
+ *
3999
4524
  */
4000
4525
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4001
4526
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4021,10 +4546,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4021
4546
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
4022
4547
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
4023
4548
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
4024
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
4549
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
4550
+ * Called when the list starts/stops scrolling.
4551
+ */
4025
4552
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4026
4553
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4027
4554
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4555
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
4556
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
4028
4557
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4029
4558
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4030
4559
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -4041,10 +4570,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4041
4570
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4042
4571
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4043
4572
  /**
4573
+ * *The property accepts pixel values.*
4574
+ *
4044
4575
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4045
4576
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4046
4577
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4047
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4578
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4579
+ *
4048
4580
  */
4049
4581
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4050
4582
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4059,7 +4591,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4059
4591
  didMount: import("@virtuoso.dev/urx").Stream<boolean>;
4060
4592
  }]) => {
4061
4593
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
4062
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4594
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
4063
4595
  }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
4064
4596
  log: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").Log>;
4065
4597
  logLevel: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").LogLevel>;
@@ -4070,10 +4602,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4070
4602
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
4071
4603
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
4072
4604
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
4073
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
4605
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
4606
+ * Called when the list starts/stops scrolling.
4607
+ */
4074
4608
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4075
4609
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4076
4610
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4611
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
4612
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
4077
4613
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4078
4614
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4079
4615
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -4090,10 +4626,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4090
4626
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4091
4627
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4092
4628
  /**
4629
+ * *The property accepts pixel values.*
4630
+ *
4093
4631
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4094
4632
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4095
4633
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4096
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4634
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4635
+ *
4097
4636
  */
4098
4637
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4099
4638
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4107,10 +4646,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4107
4646
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
4108
4647
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
4109
4648
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
4110
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
4649
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
4650
+ * Called when the list starts/stops scrolling.
4651
+ */
4111
4652
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4112
4653
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4113
4654
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4655
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
4656
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
4114
4657
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4115
4658
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4116
4659
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -4127,10 +4670,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4127
4670
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4128
4671
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4129
4672
  /**
4673
+ * *The property accepts pixel values.*
4674
+ *
4130
4675
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4131
4676
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4132
4677
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4133
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4678
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4679
+ *
4134
4680
  */
4135
4681
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4136
4682
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4152,10 +4698,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4152
4698
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4153
4699
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4154
4700
  /**
4701
+ * *The property accepts pixel values.*
4702
+ *
4155
4703
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4156
4704
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4157
4705
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4158
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4706
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4707
+ *
4159
4708
  */
4160
4709
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4161
4710
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4171,10 +4720,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4171
4720
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4172
4721
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4173
4722
  /**
4723
+ * *The property accepts pixel values.*
4724
+ *
4174
4725
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4175
4726
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4176
4727
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4177
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4728
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4729
+ *
4178
4730
  */
4179
4731
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4180
4732
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4205,10 +4757,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4205
4757
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
4206
4758
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
4207
4759
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
4208
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
4760
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
4761
+ * Called when the list starts/stops scrolling.
4762
+ */
4209
4763
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4210
4764
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4211
4765
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4766
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
4767
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
4212
4768
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4213
4769
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4214
4770
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -4228,7 +4784,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4228
4784
  visibleRange: import("@virtuoso.dev/urx").StatefulStream<import("./sizeRangeSystem").NumberTuple>;
4229
4785
  }, {
4230
4786
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
4231
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4787
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
4232
4788
  }, {
4233
4789
  scrollToIndex: import("@virtuoso.dev/urx").Stream<import("./scrollToIndexSystem").IndexLocation>;
4234
4790
  topListHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4272,10 +4828,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4272
4828
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4273
4829
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4274
4830
  /**
4831
+ * *The property accepts pixel values.*
4832
+ *
4275
4833
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4276
4834
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4277
4835
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4278
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4836
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4837
+ *
4279
4838
  */
4280
4839
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4281
4840
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4311,10 +4870,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4311
4870
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4312
4871
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4313
4872
  /**
4873
+ * *The property accepts pixel values.*
4874
+ *
4314
4875
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4315
4876
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4316
4877
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4317
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4878
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4879
+ *
4318
4880
  */
4319
4881
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4320
4882
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4331,10 +4893,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4331
4893
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
4332
4894
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
4333
4895
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
4334
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
4896
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
4897
+ * Called when the list starts/stops scrolling.
4898
+ */
4335
4899
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4336
4900
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4337
4901
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4902
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
4903
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
4338
4904
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4339
4905
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4340
4906
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -4352,10 +4918,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4352
4918
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
4353
4919
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
4354
4920
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
4355
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
4921
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
4922
+ * Called when the list starts/stops scrolling.
4923
+ */
4356
4924
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4357
4925
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4358
4926
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4927
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
4928
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
4359
4929
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4360
4930
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4361
4931
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -4372,10 +4942,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4372
4942
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4373
4943
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4374
4944
  /**
4945
+ * *The property accepts pixel values.*
4946
+ *
4375
4947
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4376
4948
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4377
4949
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4378
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4950
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4951
+ *
4379
4952
  */
4380
4953
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4381
4954
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4386,10 +4959,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4386
4959
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
4387
4960
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
4388
4961
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
4389
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
4962
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
4963
+ * Called when the list starts/stops scrolling.
4964
+ */
4390
4965
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4391
4966
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4392
4967
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4968
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
4969
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
4393
4970
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4394
4971
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4395
4972
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -4406,10 +4983,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4406
4983
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4407
4984
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4408
4985
  /**
4986
+ * *The property accepts pixel values.*
4987
+ *
4409
4988
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4410
4989
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4411
4990
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4412
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
4991
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
4992
+ *
4413
4993
  */
4414
4994
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4415
4995
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4428,10 +5008,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4428
5008
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4429
5009
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4430
5010
  /**
5011
+ * *The property accepts pixel values.*
5012
+ *
4431
5013
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4432
5014
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4433
5015
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4434
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5016
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5017
+ *
4435
5018
  */
4436
5019
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4437
5020
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4447,10 +5030,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4447
5030
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4448
5031
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4449
5032
  /**
5033
+ * *The property accepts pixel values.*
5034
+ *
4450
5035
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4451
5036
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4452
5037
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4453
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5038
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5039
+ *
4454
5040
  */
4455
5041
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4456
5042
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4474,10 +5060,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4474
5060
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
4475
5061
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
4476
5062
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
4477
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
5063
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
5064
+ * Called when the list starts/stops scrolling.
5065
+ */
4478
5066
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4479
5067
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4480
5068
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5069
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
5070
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
4481
5071
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4482
5072
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4483
5073
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -4494,10 +5084,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4494
5084
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4495
5085
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4496
5086
  /**
5087
+ * *The property accepts pixel values.*
5088
+ *
4497
5089
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4498
5090
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4499
5091
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4500
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5092
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5093
+ *
4501
5094
  */
4502
5095
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4503
5096
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4514,10 +5107,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4514
5107
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
4515
5108
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
4516
5109
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
4517
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
5110
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
5111
+ * Called when the list starts/stops scrolling.
5112
+ */
4518
5113
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4519
5114
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4520
5115
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5116
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
5117
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
4521
5118
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4522
5119
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4523
5120
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -4534,10 +5131,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4534
5131
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4535
5132
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4536
5133
  /**
5134
+ * *The property accepts pixel values.*
5135
+ *
4537
5136
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4538
5137
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4539
5138
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4540
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5139
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5140
+ *
4541
5141
  */
4542
5142
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4543
5143
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4551,10 +5151,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4551
5151
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
4552
5152
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
4553
5153
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
4554
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
5154
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
5155
+ * Called when the list starts/stops scrolling.
5156
+ */
4555
5157
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4556
5158
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4557
5159
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5160
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
5161
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
4558
5162
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4559
5163
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4560
5164
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -4571,10 +5175,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4571
5175
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4572
5176
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4573
5177
  /**
5178
+ * *The property accepts pixel values.*
5179
+ *
4574
5180
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4575
5181
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4576
5182
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4577
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5183
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5184
+ *
4578
5185
  */
4579
5186
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4580
5187
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4600,10 +5207,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4600
5207
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
4601
5208
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
4602
5209
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
4603
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
5210
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
5211
+ * Called when the list starts/stops scrolling.
5212
+ */
4604
5213
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4605
5214
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4606
5215
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5216
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
5217
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
4607
5218
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4608
5219
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4609
5220
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -4620,10 +5231,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4620
5231
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4621
5232
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4622
5233
  /**
5234
+ * *The property accepts pixel values.*
5235
+ *
4623
5236
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4624
5237
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4625
5238
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4626
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5239
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5240
+ *
4627
5241
  */
4628
5242
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4629
5243
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4638,7 +5252,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4638
5252
  didMount: import("@virtuoso.dev/urx").Stream<boolean>;
4639
5253
  }]) => {
4640
5254
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
4641
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5255
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
4642
5256
  }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
4643
5257
  log: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").Log>;
4644
5258
  logLevel: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").LogLevel>;
@@ -4649,10 +5263,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4649
5263
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
4650
5264
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
4651
5265
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
4652
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
5266
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
5267
+ * Called when the list starts/stops scrolling.
5268
+ */
4653
5269
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4654
5270
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4655
5271
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5272
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
5273
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
4656
5274
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4657
5275
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4658
5276
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -4669,10 +5287,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4669
5287
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4670
5288
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4671
5289
  /**
5290
+ * *The property accepts pixel values.*
5291
+ *
4672
5292
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4673
5293
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4674
5294
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4675
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5295
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5296
+ *
4676
5297
  */
4677
5298
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4678
5299
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4686,10 +5307,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4686
5307
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
4687
5308
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
4688
5309
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
4689
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
5310
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
5311
+ * Called when the list starts/stops scrolling.
5312
+ */
4690
5313
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4691
5314
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4692
5315
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5316
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
5317
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
4693
5318
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4694
5319
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4695
5320
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -4706,10 +5331,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4706
5331
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4707
5332
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4708
5333
  /**
5334
+ * *The property accepts pixel values.*
5335
+ *
4709
5336
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4710
5337
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4711
5338
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4712
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5339
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5340
+ *
4713
5341
  */
4714
5342
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4715
5343
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4731,10 +5359,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4731
5359
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4732
5360
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4733
5361
  /**
5362
+ * *The property accepts pixel values.*
5363
+ *
4734
5364
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4735
5365
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4736
5366
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4737
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5367
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5368
+ *
4738
5369
  */
4739
5370
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4740
5371
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4750,10 +5381,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4750
5381
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4751
5382
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4752
5383
  /**
5384
+ * *The property accepts pixel values.*
5385
+ *
4753
5386
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4754
5387
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4755
5388
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4756
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5389
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5390
+ *
4757
5391
  */
4758
5392
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4759
5393
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4784,10 +5418,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4784
5418
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
4785
5419
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
4786
5420
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
4787
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
5421
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
5422
+ * Called when the list starts/stops scrolling.
5423
+ */
4788
5424
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4789
5425
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4790
5426
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5427
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
5428
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
4791
5429
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4792
5430
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4793
5431
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -4807,7 +5445,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4807
5445
  visibleRange: import("@virtuoso.dev/urx").StatefulStream<import("./sizeRangeSystem").NumberTuple>;
4808
5446
  }, {
4809
5447
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
4810
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5448
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
4811
5449
  }, {
4812
5450
  scrollToIndex: import("@virtuoso.dev/urx").Stream<import("./scrollToIndexSystem").IndexLocation>;
4813
5451
  topListHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -4851,10 +5489,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4851
5489
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4852
5490
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4853
5491
  /**
5492
+ * *The property accepts pixel values.*
5493
+ *
4854
5494
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4855
5495
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4856
5496
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4857
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5497
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5498
+ *
4858
5499
  */
4859
5500
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4860
5501
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4899,10 +5540,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4899
5540
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4900
5541
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4901
5542
  /**
5543
+ * *The property accepts pixel values.*
5544
+ *
4902
5545
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4903
5546
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4904
5547
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4905
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5548
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5549
+ *
4906
5550
  */
4907
5551
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4908
5552
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4924,10 +5568,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4924
5568
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4925
5569
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4926
5570
  /**
5571
+ * *The property accepts pixel values.*
5572
+ *
4927
5573
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4928
5574
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4929
5575
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4930
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5576
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5577
+ *
4931
5578
  */
4932
5579
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4933
5580
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4945,10 +5592,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4945
5592
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4946
5593
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4947
5594
  /**
5595
+ * *The property accepts pixel values.*
5596
+ *
4948
5597
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4949
5598
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4950
5599
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4951
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5600
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5601
+ *
4952
5602
  */
4953
5603
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4954
5604
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4964,10 +5614,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4964
5614
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
4965
5615
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
4966
5616
  /**
5617
+ * *The property accepts pixel values.*
5618
+ *
4967
5619
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
4968
5620
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
4969
5621
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
4970
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5622
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5623
+ *
4971
5624
  */
4972
5625
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
4973
5626
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -4984,10 +5637,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
4984
5637
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
4985
5638
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
4986
5639
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
4987
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
5640
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
5641
+ * Called when the list starts/stops scrolling.
5642
+ */
4988
5643
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4989
5644
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
4990
5645
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5646
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
5647
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
4991
5648
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
4992
5649
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
4993
5650
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5005,10 +5662,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5005
5662
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5006
5663
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5007
5664
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5008
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
5665
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
5666
+ * Called when the list starts/stops scrolling.
5667
+ */
5009
5668
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5010
5669
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5011
5670
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5671
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
5672
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5012
5673
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5013
5674
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5014
5675
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5025,10 +5686,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5025
5686
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5026
5687
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5027
5688
  /**
5689
+ * *The property accepts pixel values.*
5690
+ *
5028
5691
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5029
5692
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5030
5693
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5031
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5694
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5695
+ *
5032
5696
  */
5033
5697
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5034
5698
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5039,10 +5703,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5039
5703
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5040
5704
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5041
5705
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5042
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
5706
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
5707
+ * Called when the list starts/stops scrolling.
5708
+ */
5043
5709
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5044
5710
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5045
5711
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5712
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
5713
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5046
5714
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5047
5715
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5048
5716
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5059,10 +5727,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5059
5727
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5060
5728
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5061
5729
  /**
5730
+ * *The property accepts pixel values.*
5731
+ *
5062
5732
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5063
5733
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5064
5734
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5065
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5735
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5736
+ *
5066
5737
  */
5067
5738
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5068
5739
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5081,10 +5752,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5081
5752
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5082
5753
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5083
5754
  /**
5755
+ * *The property accepts pixel values.*
5756
+ *
5084
5757
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5085
5758
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5086
5759
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5087
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5760
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5761
+ *
5088
5762
  */
5089
5763
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5090
5764
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5100,10 +5774,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5100
5774
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5101
5775
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5102
5776
  /**
5777
+ * *The property accepts pixel values.*
5778
+ *
5103
5779
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5104
5780
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5105
5781
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5106
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5782
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5783
+ *
5107
5784
  */
5108
5785
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5109
5786
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5127,10 +5804,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5127
5804
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5128
5805
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5129
5806
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5130
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
5807
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
5808
+ * Called when the list starts/stops scrolling.
5809
+ */
5131
5810
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5132
5811
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5133
5812
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5813
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
5814
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5134
5815
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5135
5816
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5136
5817
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5147,10 +5828,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5147
5828
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5148
5829
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5149
5830
  /**
5831
+ * *The property accepts pixel values.*
5832
+ *
5150
5833
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5151
5834
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5152
5835
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5153
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5836
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5837
+ *
5154
5838
  */
5155
5839
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5156
5840
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5167,10 +5851,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5167
5851
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5168
5852
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5169
5853
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5170
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
5854
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
5855
+ * Called when the list starts/stops scrolling.
5856
+ */
5171
5857
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5172
5858
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5173
5859
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5860
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
5861
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5174
5862
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5175
5863
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5176
5864
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5187,10 +5875,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5187
5875
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5188
5876
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5189
5877
  /**
5878
+ * *The property accepts pixel values.*
5879
+ *
5190
5880
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5191
5881
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5192
5882
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5193
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5883
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5884
+ *
5194
5885
  */
5195
5886
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5196
5887
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5204,10 +5895,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5204
5895
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5205
5896
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5206
5897
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5207
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
5898
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
5899
+ * Called when the list starts/stops scrolling.
5900
+ */
5208
5901
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5209
5902
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5210
5903
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5904
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
5905
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5211
5906
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5212
5907
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5213
5908
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5224,10 +5919,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5224
5919
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5225
5920
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5226
5921
  /**
5922
+ * *The property accepts pixel values.*
5923
+ *
5227
5924
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5228
5925
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5229
5926
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5230
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5927
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5928
+ *
5231
5929
  */
5232
5930
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5233
5931
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5253,10 +5951,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5253
5951
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5254
5952
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5255
5953
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5256
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
5954
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
5955
+ * Called when the list starts/stops scrolling.
5956
+ */
5257
5957
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5258
5958
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5259
5959
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5960
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
5961
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5260
5962
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5261
5963
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5262
5964
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5273,10 +5975,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5273
5975
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5274
5976
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5275
5977
  /**
5978
+ * *The property accepts pixel values.*
5979
+ *
5276
5980
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5277
5981
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5278
5982
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5279
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
5983
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
5984
+ *
5280
5985
  */
5281
5986
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5282
5987
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5291,7 +5996,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5291
5996
  didMount: import("@virtuoso.dev/urx").Stream<boolean>;
5292
5997
  }]) => {
5293
5998
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
5294
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5999
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
5295
6000
  }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
5296
6001
  log: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").Log>;
5297
6002
  logLevel: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").LogLevel>;
@@ -5302,10 +6007,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5302
6007
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5303
6008
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5304
6009
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5305
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6010
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
6011
+ * Called when the list starts/stops scrolling.
6012
+ */
5306
6013
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5307
6014
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5308
6015
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6016
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
6017
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5309
6018
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5310
6019
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5311
6020
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5322,10 +6031,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5322
6031
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5323
6032
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5324
6033
  /**
6034
+ * *The property accepts pixel values.*
6035
+ *
5325
6036
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5326
6037
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5327
6038
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5328
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6039
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6040
+ *
5329
6041
  */
5330
6042
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5331
6043
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5339,10 +6051,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5339
6051
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5340
6052
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5341
6053
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5342
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6054
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
6055
+ * Called when the list starts/stops scrolling.
6056
+ */
5343
6057
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5344
6058
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5345
6059
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6060
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
6061
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5346
6062
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5347
6063
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5348
6064
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5359,10 +6075,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5359
6075
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5360
6076
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5361
6077
  /**
6078
+ * *The property accepts pixel values.*
6079
+ *
5362
6080
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5363
6081
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5364
6082
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5365
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6083
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6084
+ *
5366
6085
  */
5367
6086
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5368
6087
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5384,10 +6103,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5384
6103
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5385
6104
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5386
6105
  /**
6106
+ * *The property accepts pixel values.*
6107
+ *
5387
6108
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5388
6109
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5389
6110
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5390
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6111
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6112
+ *
5391
6113
  */
5392
6114
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5393
6115
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5403,10 +6125,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5403
6125
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5404
6126
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5405
6127
  /**
6128
+ * *The property accepts pixel values.*
6129
+ *
5406
6130
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5407
6131
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5408
6132
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5409
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6133
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6134
+ *
5410
6135
  */
5411
6136
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5412
6137
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5437,10 +6162,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5437
6162
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5438
6163
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5439
6164
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5440
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6165
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
6166
+ * Called when the list starts/stops scrolling.
6167
+ */
5441
6168
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5442
6169
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5443
6170
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6171
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
6172
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5444
6173
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5445
6174
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5446
6175
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5460,7 +6189,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5460
6189
  visibleRange: import("@virtuoso.dev/urx").StatefulStream<import("./sizeRangeSystem").NumberTuple>;
5461
6190
  }, {
5462
6191
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
5463
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
6192
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
5464
6193
  }, {
5465
6194
  scrollToIndex: import("@virtuoso.dev/urx").Stream<import("./scrollToIndexSystem").IndexLocation>;
5466
6195
  topListHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -5504,10 +6233,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5504
6233
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5505
6234
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5506
6235
  /**
6236
+ * *The property accepts pixel values.*
6237
+ *
5507
6238
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5508
6239
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5509
6240
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5510
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6241
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6242
+ *
5511
6243
  */
5512
6244
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5513
6245
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5543,10 +6275,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5543
6275
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5544
6276
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5545
6277
  /**
6278
+ * *The property accepts pixel values.*
6279
+ *
5546
6280
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5547
6281
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5548
6282
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5549
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6283
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6284
+ *
5550
6285
  */
5551
6286
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5552
6287
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5568,10 +6303,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5568
6303
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5569
6304
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5570
6305
  /**
6306
+ * *The property accepts pixel values.*
6307
+ *
5571
6308
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5572
6309
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5573
6310
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5574
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6311
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6312
+ *
5575
6313
  */
5576
6314
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5577
6315
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5587,10 +6325,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5587
6325
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5588
6326
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5589
6327
  /**
6328
+ * *The property accepts pixel values.*
6329
+ *
5590
6330
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5591
6331
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5592
6332
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5593
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6333
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6334
+ *
5594
6335
  */
5595
6336
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5596
6337
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5613,10 +6354,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5613
6354
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5614
6355
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5615
6356
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5616
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6357
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
6358
+ * Called when the list starts/stops scrolling.
6359
+ */
5617
6360
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5618
6361
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5619
6362
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6363
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
6364
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5620
6365
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5621
6366
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5622
6367
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5633,10 +6378,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5633
6378
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5634
6379
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5635
6380
  /**
6381
+ * *The property accepts pixel values.*
6382
+ *
5636
6383
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5637
6384
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5638
6385
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5639
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6386
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6387
+ *
5640
6388
  */
5641
6389
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5642
6390
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5653,10 +6401,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5653
6401
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5654
6402
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5655
6403
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5656
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6404
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
6405
+ * Called when the list starts/stops scrolling.
6406
+ */
5657
6407
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5658
6408
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5659
6409
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6410
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
6411
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5660
6412
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5661
6413
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5662
6414
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5673,10 +6425,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5673
6425
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5674
6426
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5675
6427
  /**
6428
+ * *The property accepts pixel values.*
6429
+ *
5676
6430
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5677
6431
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5678
6432
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5679
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6433
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6434
+ *
5680
6435
  */
5681
6436
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5682
6437
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5690,10 +6445,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5690
6445
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5691
6446
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5692
6447
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5693
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6448
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
6449
+ * Called when the list starts/stops scrolling.
6450
+ */
5694
6451
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5695
6452
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5696
6453
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6454
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
6455
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5697
6456
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5698
6457
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5699
6458
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5710,10 +6469,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5710
6469
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5711
6470
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5712
6471
  /**
6472
+ * *The property accepts pixel values.*
6473
+ *
5713
6474
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5714
6475
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5715
6476
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5716
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6477
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6478
+ *
5717
6479
  */
5718
6480
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5719
6481
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5736,10 +6498,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5736
6498
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5737
6499
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5738
6500
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5739
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6501
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
6502
+ * Called when the list starts/stops scrolling.
6503
+ */
5740
6504
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5741
6505
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5742
6506
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6507
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
6508
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5743
6509
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5744
6510
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5745
6511
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5757,10 +6523,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5757
6523
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5758
6524
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5759
6525
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5760
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6526
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
6527
+ * Called when the list starts/stops scrolling.
6528
+ */
5761
6529
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5762
6530
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5763
6531
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6532
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
6533
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5764
6534
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5765
6535
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5766
6536
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5777,10 +6547,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5777
6547
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5778
6548
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5779
6549
  /**
6550
+ * *The property accepts pixel values.*
6551
+ *
5780
6552
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5781
6553
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5782
6554
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5783
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6555
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6556
+ *
5784
6557
  */
5785
6558
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5786
6559
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5791,10 +6564,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5791
6564
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5792
6565
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5793
6566
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5794
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6567
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
6568
+ * Called when the list starts/stops scrolling.
6569
+ */
5795
6570
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5796
6571
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5797
6572
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6573
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
6574
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5798
6575
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5799
6576
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5800
6577
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5811,10 +6588,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5811
6588
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5812
6589
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5813
6590
  /**
6591
+ * *The property accepts pixel values.*
6592
+ *
5814
6593
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5815
6594
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5816
6595
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5817
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6596
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6597
+ *
5818
6598
  */
5819
6599
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5820
6600
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5833,10 +6613,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5833
6613
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5834
6614
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5835
6615
  /**
6616
+ * *The property accepts pixel values.*
6617
+ *
5836
6618
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5837
6619
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5838
6620
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5839
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6621
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6622
+ *
5840
6623
  */
5841
6624
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5842
6625
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5852,10 +6635,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5852
6635
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5853
6636
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5854
6637
  /**
6638
+ * *The property accepts pixel values.*
6639
+ *
5855
6640
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5856
6641
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5857
6642
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5858
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6643
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6644
+ *
5859
6645
  */
5860
6646
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5861
6647
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5879,10 +6665,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5879
6665
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5880
6666
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5881
6667
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5882
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6668
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
6669
+ * Called when the list starts/stops scrolling.
6670
+ */
5883
6671
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5884
6672
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5885
6673
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6674
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
6675
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5886
6676
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5887
6677
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5888
6678
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5899,10 +6689,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5899
6689
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5900
6690
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5901
6691
  /**
6692
+ * *The property accepts pixel values.*
6693
+ *
5902
6694
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5903
6695
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5904
6696
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5905
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6697
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6698
+ *
5906
6699
  */
5907
6700
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5908
6701
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5919,10 +6712,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5919
6712
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5920
6713
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5921
6714
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5922
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6715
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
6716
+ * Called when the list starts/stops scrolling.
6717
+ */
5923
6718
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5924
6719
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5925
6720
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6721
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
6722
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5926
6723
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5927
6724
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5928
6725
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5939,10 +6736,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5939
6736
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5940
6737
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5941
6738
  /**
6739
+ * *The property accepts pixel values.*
6740
+ *
5942
6741
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5943
6742
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5944
6743
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5945
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6744
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6745
+ *
5946
6746
  */
5947
6747
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5948
6748
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -5956,10 +6756,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5956
6756
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
5957
6757
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
5958
6758
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
5959
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6759
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
6760
+ * Called when the list starts/stops scrolling.
6761
+ */
5960
6762
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5961
6763
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
5962
6764
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6765
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
6766
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
5963
6767
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
5964
6768
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
5965
6769
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -5976,10 +6780,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
5976
6780
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
5977
6781
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
5978
6782
  /**
6783
+ * *The property accepts pixel values.*
6784
+ *
5979
6785
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
5980
6786
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
5981
6787
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
5982
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6788
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6789
+ *
5983
6790
  */
5984
6791
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
5985
6792
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -6005,10 +6812,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6005
6812
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
6006
6813
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
6007
6814
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
6008
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6815
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
6816
+ * Called when the list starts/stops scrolling.
6817
+ */
6009
6818
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
6010
6819
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
6011
6820
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6821
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
6822
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
6012
6823
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6013
6824
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
6014
6825
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -6025,10 +6836,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6025
6836
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
6026
6837
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
6027
6838
  /**
6839
+ * *The property accepts pixel values.*
6840
+ *
6028
6841
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
6029
6842
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
6030
6843
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
6031
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6844
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6845
+ *
6032
6846
  */
6033
6847
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
6034
6848
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -6043,7 +6857,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6043
6857
  didMount: import("@virtuoso.dev/urx").Stream<boolean>;
6044
6858
  }]) => {
6045
6859
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
6046
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
6860
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
6047
6861
  }>, import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
6048
6862
  log: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").Log>;
6049
6863
  logLevel: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").LogLevel>;
@@ -6054,10 +6868,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6054
6868
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
6055
6869
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
6056
6870
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
6057
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6871
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
6872
+ * Called when the list starts/stops scrolling.
6873
+ */
6058
6874
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
6059
6875
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
6060
6876
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6877
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
6878
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
6061
6879
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6062
6880
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
6063
6881
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -6074,10 +6892,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6074
6892
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
6075
6893
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
6076
6894
  /**
6895
+ * *The property accepts pixel values.*
6896
+ *
6077
6897
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
6078
6898
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
6079
6899
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
6080
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6900
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6901
+ *
6081
6902
  */
6082
6903
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
6083
6904
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -6091,10 +6912,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6091
6912
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
6092
6913
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
6093
6914
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
6094
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6915
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
6916
+ * Called when the list starts/stops scrolling.
6917
+ */
6095
6918
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
6096
6919
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
6097
6920
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6921
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
6922
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
6098
6923
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6099
6924
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
6100
6925
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -6111,10 +6936,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6111
6936
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
6112
6937
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
6113
6938
  /**
6939
+ * *The property accepts pixel values.*
6940
+ *
6114
6941
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
6115
6942
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
6116
6943
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
6117
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6944
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6945
+ *
6118
6946
  */
6119
6947
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
6120
6948
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -6136,10 +6964,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6136
6964
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
6137
6965
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
6138
6966
  /**
6967
+ * *The property accepts pixel values.*
6968
+ *
6139
6969
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
6140
6970
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
6141
6971
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
6142
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6972
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6973
+ *
6143
6974
  */
6144
6975
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
6145
6976
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -6155,10 +6986,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6155
6986
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
6156
6987
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
6157
6988
  /**
6989
+ * *The property accepts pixel values.*
6990
+ *
6158
6991
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
6159
6992
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
6160
6993
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
6161
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6994
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
6995
+ *
6162
6996
  */
6163
6997
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
6164
6998
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -6189,10 +7023,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6189
7023
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
6190
7024
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
6191
7025
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
6192
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
7026
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
7027
+ * Called when the list starts/stops scrolling.
7028
+ */
6193
7029
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
6194
7030
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
6195
7031
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
7032
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
7033
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
6196
7034
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6197
7035
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
6198
7036
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -6212,7 +7050,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6212
7050
  visibleRange: import("@virtuoso.dev/urx").StatefulStream<import("./sizeRangeSystem").NumberTuple>;
6213
7051
  }, {
6214
7052
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
6215
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
7053
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
6216
7054
  }, {
6217
7055
  scrollToIndex: import("@virtuoso.dev/urx").Stream<import("./scrollToIndexSystem").IndexLocation>;
6218
7056
  topListHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
@@ -6254,10 +7092,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6254
7092
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
6255
7093
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
6256
7094
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
6257
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
7095
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
7096
+ * Called when the list starts/stops scrolling.
7097
+ */
6258
7098
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
6259
7099
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
6260
7100
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
7101
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
7102
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
6261
7103
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6262
7104
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
6263
7105
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -6274,10 +7116,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6274
7116
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
6275
7117
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
6276
7118
  /**
7119
+ * *The property accepts pixel values.*
7120
+ *
6277
7121
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
6278
7122
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
6279
7123
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
6280
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
7124
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
7125
+ *
6281
7126
  */
6282
7127
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
6283
7128
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -6374,10 +7219,14 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6374
7219
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
6375
7220
  totalCount: import("@virtuoso.dev/urx").Stream<number>;
6376
7221
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
6377
- groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
7222
+ groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>; /**
7223
+ * Called when the list starts/stops scrolling.
7224
+ */
6378
7225
  defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
6379
7226
  fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
6380
7227
  unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
7228
+ shiftWith: import("@virtuoso.dev/urx").Stream<number>;
7229
+ shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
6381
7230
  beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
6382
7231
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
6383
7232
  sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
@@ -6387,7 +7236,7 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6387
7236
  itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
6388
7237
  }, {
6389
7238
  scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
6390
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
7239
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
6391
7240
  }, {
6392
7241
  scrollContainerState: import("@virtuoso.dev/urx").Stream<[number, number]>;
6393
7242
  scrollTop: import("@virtuoso.dev/urx").Stream<number>;
@@ -6397,10 +7246,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6397
7246
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
6398
7247
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
6399
7248
  /**
7249
+ * *The property accepts pixel values.*
7250
+ *
6400
7251
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
6401
7252
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
6402
7253
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
6403
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
7254
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
7255
+ *
6404
7256
  */
6405
7257
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
6406
7258
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -6475,10 +7327,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6475
7327
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
6476
7328
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
6477
7329
  /**
7330
+ * *The property accepts pixel values.*
7331
+ *
6478
7332
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
6479
7333
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
6480
7334
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
6481
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
7335
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
7336
+ *
6482
7337
  */
6483
7338
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
6484
7339
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -6523,6 +7378,10 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6523
7378
  rangeChanged: import("@virtuoso.dev/urx").Stream<ListRange>;
6524
7379
  itemsRendered: import("@virtuoso.dev/urx").Stream<import("./listStateSystem").ListItems>;
6525
7380
  statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
7381
+ /**
7382
+ * Use for server-side rendering - if set, the list will render the specified amount of items
7383
+ * regardless of the container / item size.
7384
+ */
6526
7385
  listState: import("@virtuoso.dev/urx").StatefulStream<import("./listStateSystem").ListState>;
6527
7386
  scrollToIndex: import("@virtuoso.dev/urx").Stream<import("./scrollToIndexSystem").IndexLocation>;
6528
7387
  trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
@@ -6533,11 +7392,8 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6533
7392
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
6534
7393
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
6535
7394
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
6536
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
6537
- scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>; /**
6538
- * Use for server-side rendering - if set, the list will render the specified amount of items
6539
- * regardless of the container / item size.
6540
- */
7395
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
7396
+ scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
6541
7397
  topItemsIndexes: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6542
7398
  topItemCount: import("@virtuoso.dev/urx").StatefulStream<number>;
6543
7399
  groupCounts: import("@virtuoso.dev/urx").Stream<number[]>;
@@ -6594,10 +7450,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6594
7450
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
6595
7451
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
6596
7452
  /**
7453
+ * *The property accepts pixel values.*
7454
+ *
6597
7455
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
6598
7456
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
6599
7457
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
6600
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
7458
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
7459
+ *
6601
7460
  */
6602
7461
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
6603
7462
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -6642,6 +7501,10 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6642
7501
  rangeChanged: import("@virtuoso.dev/urx").Stream<ListRange>;
6643
7502
  itemsRendered: import("@virtuoso.dev/urx").Stream<import("./listStateSystem").ListItems>;
6644
7503
  statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
7504
+ /**
7505
+ * Use for server-side rendering - if set, the list will render the specified amount of items
7506
+ * regardless of the container / item size.
7507
+ */
6645
7508
  listState: import("@virtuoso.dev/urx").StatefulStream<import("./listStateSystem").ListState>;
6646
7509
  scrollToIndex: import("@virtuoso.dev/urx").Stream<import("./scrollToIndexSystem").IndexLocation>;
6647
7510
  trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
@@ -6652,11 +7515,8 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6652
7515
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
6653
7516
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
6654
7517
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
6655
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
6656
- scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>; /**
6657
- * Use for server-side rendering - if set, the list will render the specified amount of items
6658
- * regardless of the container / item size.
6659
- */
7518
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
7519
+ scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
6660
7520
  topItemsIndexes: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6661
7521
  topItemCount: import("@virtuoso.dev/urx").StatefulStream<number>;
6662
7522
  groupCounts: import("@virtuoso.dev/urx").Stream<number[]>;
@@ -6752,10 +7612,13 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6752
7612
  scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
6753
7613
  smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
6754
7614
  /**
7615
+ * *The property accepts pixel values.*
7616
+ *
6755
7617
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
6756
7618
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
6757
7619
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
6758
- * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
7620
+ * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in react-window).
7621
+ *
6759
7622
  */
6760
7623
  scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
6761
7624
  scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
@@ -6800,6 +7663,10 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6800
7663
  rangeChanged: import("@virtuoso.dev/urx").Stream<ListRange>;
6801
7664
  itemsRendered: import("@virtuoso.dev/urx").Stream<import("./listStateSystem").ListItems>;
6802
7665
  statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
7666
+ /**
7667
+ * Use for server-side rendering - if set, the list will render the specified amount of items
7668
+ * regardless of the container / item size.
7669
+ */
6803
7670
  listState: import("@virtuoso.dev/urx").StatefulStream<import("./listStateSystem").ListState>;
6804
7671
  scrollToIndex: import("@virtuoso.dev/urx").Stream<import("./scrollToIndexSystem").IndexLocation>;
6805
7672
  trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
@@ -6810,11 +7677,8 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6810
7677
  data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
6811
7678
  firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
6812
7679
  sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
6813
- initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
6814
- scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>; /**
6815
- * Use for server-side rendering - if set, the list will render the specified amount of items
6816
- * regardless of the container / item size.
6817
- */
7680
+ initialTopMostItemIndex: import("@virtuoso.dev/urx").StatefulStream<import("./scrollToIndexSystem").IndexLocation>;
7681
+ scrolledToInitialItem: import("@virtuoso.dev/urx").StatefulStream<boolean>;
6818
7682
  topItemsIndexes: import("@virtuoso.dev/urx").StatefulStream<number[]>;
6819
7683
  topItemCount: import("@virtuoso.dev/urx").StatefulStream<number>;
6820
7684
  groupCounts: import("@virtuoso.dev/urx").Stream<number[]>;
@@ -6839,24 +7703,22 @@ export declare const TableVirtuoso: <ItemData extends unknown = any, Context ext
6839
7703
  computeItemKey: "computeItemKey";
6840
7704
  defaultItemHeight: "defaultItemHeight";
6841
7705
  fixedItemHeight: "fixedItemHeight";
6842
- /**
6843
- * The data items to be rendered. If data is set, the total count will be inferred from the length of the array.
7706
+ itemSize: "itemSize"; /**
7707
+ * Set the contents of the table header.
6844
7708
  */
6845
- itemSize: "itemSize";
6846
7709
  scrollSeekConfiguration: "scrollSeekConfiguration";
6847
7710
  data: "data";
6848
7711
  initialItemCount: "initialItemCount";
6849
- /**
7712
+ initialScrollTop: "initialScrollTop";
7713
+ alignToBottom: "alignToBottom";
7714
+ useWindowScroll: "useWindowScroll";
7715
+ customScrollParent: "customScrollParent";
7716
+ scrollerRef: "scrollerRef"; /**
6850
7717
  * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
6851
7718
  * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
6852
7719
  * Setting `{ main: number, reverse: number }` lets you extend the list in both the main and the reverse scrollable directions.
6853
7720
  * See the `increaseViewportBy` property for a similar behavior (equivalent to the `overscan` in `react-window`).
6854
7721
  */
6855
- initialScrollTop: "initialScrollTop";
6856
- alignToBottom: "alignToBottom";
6857
- useWindowScroll: "useWindowScroll";
6858
- customScrollParent: "customScrollParent";
6859
- scrollerRef: "scrollerRef";
6860
7722
  logLevel: "logLevel";
6861
7723
  };
6862
7724
  methods: {