react-virtuoso 4.17.0 → 4.18.1

package/dist/index.d.ts

@@ -3,17 +3,35 @@ import { default as default_2 } from 'react';
 declare interface BaseTableVirtuosoHandle {
     /**
      * Obtains the internal size state of the component, so that it can be restored later. This does not include the data items.
+     * @param stateCb - Callback that receives the state snapshot
      */
     getState(stateCb: StateCallback): void;
+    /**
+     * Scrolls the component by the specified amount.
+     * @param location - The scroll offset options
+     */
     scrollBy(location: ScrollToOptions): void;
+    /**
+     * Scrolls the component to the specified position.
+     * @param location - The scroll position options
+     */
     scrollTo(location: ScrollToOptions): void;
 }
 
+/**
+ * @group Common
+ */
 export declare type CalculateViewLocation = (params: CalculateViewLocationParams) => IndexLocationWithAlign | null | number;
 
+/**
+ * @group Common
+ */
 export declare interface CalculateViewLocationParams {
+    /** The bottom edge position of the item in pixels */
     itemBottom: number;
+    /** The top edge position of the item in pixels */
     itemTop: number;
+    /** The scroll location parameters including alignment and behavior options */
     locationParams: {
         align?: 'center' | 'end' | 'start';
         behavior?: 'auto' | 'smooth';
@@ -22,12 +40,30 @@ export declare interface CalculateViewLocationParams {
     } | {
         index: number;
     });
+    /** The bottom edge position of the viewport in pixels */
     viewportBottom: number;
+    /** The top edge position of the viewport in pixels */
     viewportTop: number;
 }
 
 /**
  * Customize the Virtuoso rendering by passing a set of custom components.
+ *
+ * @typeParam Data - The type of data items in the list
+ * @typeParam Context - The type of additional context passed to components
+ *
+ * @example
+ * ```tsx
+ * const components: Components<User, AppContext> = {
+ *   Item: ({ children, context }) => <div className="item">{children}</div>,
+ *   Header: ({ context }) => <div>Header</div>,
+ *   Footer: ({ context }) => <div>Footer</div>,
+ * }
+ * <Virtuoso components={components} />
+ * ```
+ *
+ * @see {@link VirtuosoProps.components} for usage in Virtuoso
+ * @group Virtuoso
  */
 export declare interface Components<Data = unknown, Context = unknown> {
     /**
@@ -72,28 +108,83 @@ export declare interface Components<Data = unknown, Context = unknown> {
     TopItemList?: default_2.ComponentType<TopItemListProps & ContextProp<Context>>;
 }
 
-export declare type ComputeItemKey<D, C> = (index: number, item: D, context: C) => default_2.Key;
+/**
+ * Callback type for computing unique keys for list items.
+ *
+ * @typeParam Data - The type of the data item
+ * @typeParam Context - The type of context passed from the component
+ *
+ * @see {@link VirtuosoProps.computeItemKey} for usage in Virtuoso
+ * @group Common
+ */
+export declare type ComputeItemKey<Data, Context> = (index: number, item: Data, context: Context) => default_2.Key;
 
-export declare interface ContextProp<C> {
-    context: C;
+/**
+ * @group Common
+ */
+export declare interface ContextProp<Context> {
+    /** The context value passed from the parent component */
+    context: Context;
 }
 
+/**
+ * Dimensions of an element in pixels.
+ *
+ * @group VirtuosoGrid
+ */
 export declare interface ElementDimensions {
+    /** Height in pixels */
     height: number;
+    /** Width in pixels */
     width: number;
 }
 
 /**
  * Passed to the Components.FillerRow custom component
+ * @group TableVirtuoso
  */
 export declare interface FillerRowProps {
+    /** The height of the filler row in pixels */
     height: number;
 }
 
+/**
+ * Callback type for rendering fixed footer content in a table.
+ * The footer remains visible at the bottom of the viewport.
+ *
+ * @example
+ * ```tsx
+ * const fixedFooterContent: FixedFooterContent = () => (
+ *   <tr><td>Total: 100 items</td></tr>
+ * )
+ * <TableVirtuoso fixedFooterContent={fixedFooterContent} />
+ * ```
+ *
+ * @see {@link TableVirtuosoProps.fixedFooterContent} for usage
+ * @group TableVirtuoso
+ */
 export declare type FixedFooterContent = (() => default_2.ReactNode) | null;
 
+/**
+ * Callback type for rendering fixed header content in a table.
+ * The header remains visible at the top of the viewport.
+ *
+ * @example
+ * ```tsx
+ * const fixedHeaderContent: FixedHeaderContent = () => (
+ *   <tr><th>Name</th><th>Email</th></tr>
+ * )
+ * <TableVirtuoso fixedHeaderContent={fixedHeaderContent} />
+ * ```
+ *
+ * @see {@link TableVirtuosoProps.fixedHeaderContent} for usage
+ * @group TableVirtuoso
+ */
 export declare type FixedHeaderContent = (() => default_2.ReactNode) | null;
 
+/**
+ * @group Common
+ */
 export declare interface FlatIndexLocationWithAlign extends LocationOptions {
     /**
      * The index of the item to scroll to.
@@ -101,21 +192,58 @@ export declare interface FlatIndexLocationWithAlign extends LocationOptions {
     index: 'LAST' | number;
 }
 
+/**
+ * @group Common
+ */
 export declare interface FlatScrollIntoViewLocation extends ScrollIntoViewLocationOptions {
+    /** The index of the item to scroll into view */
     index: number;
 }
 
+/**
+ * @group Common
+ */
 export declare type FollowOutput = FollowOutputCallback | FollowOutputScalarType;
 
+/**
+ * @group Common
+ */
 export declare type FollowOutputCallback = (isAtBottom: boolean) => FollowOutputScalarType;
 
+/**
+ * @group Common
+ */
 export declare type FollowOutputScalarType = 'auto' | 'smooth' | boolean;
 
+/**
+ * Gap between grid items in pixels.
+ *
+ * @group VirtuosoGrid
+ */
 export declare interface Gap {
+    /** Horizontal gap between columns */
     column: number;
+    /** Vertical gap between rows */
     row: number;
 }
 
+/**
+ * Customize the VirtuosoGrid rendering by passing a set of custom components.
+ *
+ * @typeParam Context - The type of additional context passed to components
+ *
+ * @example
+ * ```tsx
+ * const components: GridComponents<AppContext> = {
+ *   Item: ({ children, className }) => <div className={className}>{children}</div>,
+ *   Header: ({ context }) => <div>Header</div>,
+ * }
+ * <VirtuosoGrid components={components} />
+ * ```
+ *
+ * @see {@link VirtuosoGridProps.components} for usage in VirtuosoGrid
+ * @group VirtuosoGrid
+ */
 export declare interface GridComponents<Context = any> {
     /**
      * Set to render a component at the bottom of the list.
@@ -147,65 +275,197 @@ export declare interface GridComponents<Context = any> {
     ScrollSeekPlaceholder?: default_2.ComponentType<GridScrollSeekPlaceholderProps & ContextProp<Context>>;
 }
 
-export declare type GridComputeItemKey<D, C> = (index: number, item: D, context: C) => default_2.Key;
+/**
+ * Callback type for computing unique keys for grid items.
+ *
+ * @typeParam Data - The type of the data item
+ * @typeParam Context - The type of context passed from the component
+ *
+ * @see {@link VirtuosoGridProps.computeItemKey} for usage
+ * @group VirtuosoGrid
+ */
+export declare type GridComputeItemKey<Data, Context> = (index: number, item: Data, context: Context) => default_2.Key;
 
+/**
+ * @group VirtuosoGrid
+ */
 export declare type GridIndexLocation = FlatIndexLocationWithAlign | number;
 
-export declare interface GridItem<D> {
-    data?: D;
+/**
+ * @group VirtuosoGrid
+ */
+export declare interface GridItem<Data> {
+    /** The data associated with this grid item */
+    data?: Data;
+    /** The index of the item in the grid */
     index: number;
 }
 
-export declare type GridItemContent<D, C> = (index: number, data: D, context: C) => default_2.ReactNode;
+/**
+ * Callback type for rendering item content in a VirtuosoGrid.
+ *
+ * @typeParam Data - The type of the data item
+ * @typeParam Context - The type of context passed from the component
+ *
+ * @example
+ * ```tsx
+ * const itemContent: GridItemContent<Product, AppContext> = (index, product, context) => (
+ *   <div className="grid-item">{product.name}</div>
+ * )
+ * <VirtuosoGrid itemContent={itemContent} data={products} />
+ * ```
+ *
+ * @see {@link VirtuosoGridProps.itemContent} for usage
+ * @group VirtuosoGrid
+ */
+export declare type GridItemContent<Data, Context> = (index: number, data: Data, context: Context) => default_2.ReactNode;
 
 /**
- * Passed to the Components.Item custom component
+ * Passed to the GridComponents.Item custom component
+ * @group VirtuosoGrid
  */
 export declare type GridItemProps = Pick<default_2.ComponentProps<'div'>, 'children' | 'className' | 'style'> & default_2.RefAttributes<HTMLDivElement> & {
     'data-index': number;
 };
 
 /**
- * Passed to the Components.List custom component
+ * Passed to the GridComponents.List custom component
+ * @group VirtuosoGrid
  */
 export declare type GridListProps = Pick<default_2.ComponentProps<'div'>, 'children' | 'className' | 'style'> & default_2.RefAttributes<HTMLDivElement> & {
     'data-testid': string;
 };
 
+/**
+ * @group VirtuosoGrid
+ */
 export declare type GridRootProps = Omit<default_2.HTMLProps<HTMLDivElement>, 'data' | 'ref'>;
 
 /**
  * Passed to the GridComponents.ScrollSeekPlaceholder custom component
+ * @group VirtuosoGrid
  */
 export declare interface GridScrollSeekPlaceholderProps {
+    /** The height of the placeholder in pixels */
     height: number;
+    /** The index of the item being replaced by the placeholder */
     index: number;
+    /** The width of the placeholder in pixels */
     width: number;
 }
 
+/**
+ * A snapshot of the VirtuosoGrid state that can be saved and restored.
+ * Use this to persist scroll position and layout across page reloads.
+ *
+ * @see {@link VirtuosoGridProps.restoreStateFrom} for restoring state
+ * @see {@link VirtuosoGridProps.stateChanged} for capturing state
+ * @group VirtuosoGrid
+ */
 export declare interface GridStateSnapshot {
+    /** Gap between items */
     gap: Gap;
+    /** Item dimensions */
     item: ElementDimensions;
+    /** Scroll position in pixels */
     scrollTop: number;
+    /** Viewport dimensions */
     viewport: ElementDimensions;
 }
 
-export declare type GroupContent<C> = (index: number, context: C) => default_2.ReactNode;
+/**
+ * Callback type for rendering group header content in GroupedVirtuoso.
+ *
+ * @typeParam Context - The type of context passed from the component
+ *
+ * @example
+ * ```tsx
+ * const groupContent: GroupContent<AppContext> = (index, context) => (
+ *   <div className="group-header">Group {index}</div>
+ * )
+ * <GroupedVirtuoso groupContent={groupContent} />
+ * ```
+ *
+ * @see {@link GroupedVirtuosoProps.groupContent} for usage
+ * @group GroupedVirtuoso
+ */
+export declare type GroupContent<Context> = (index: number, context: Context) => default_2.ReactNode;
 
+/**
+ * @group GroupedVirtuoso
+ */
 export declare interface GroupedScrollIntoViewLocation extends ScrollIntoViewLocationOptions {
+    /** The index of the group to scroll into view */
     groupIndex: number;
 }
 
+/**
+ * A virtualized table component for rendering grouped tabular data with sticky group headers.
+ * Combines TableVirtuoso functionality with group support for hierarchical data.
+ *
+ * @typeParam ItemData - The type of data items in the table
+ * @typeParam Context - The type of additional context passed to callbacks
+ *
+ * @param props - {@link GroupedTableVirtuosoProps}
+ *
+ * @function
+ * @group GroupedTableVirtuoso
+ *
+ * @example
+ * ```tsx
+ * <GroupedTableVirtuoso
+ *   groupCounts={[10, 20, 15]}
+ *   groupContent={(index) => (
+ *     <td colSpan={2}>Group {index}</td>
+ *   )}
+ *   itemContent={(index, groupIndex) => (
+ *     <>
+ *       <td>Item {index}</td>
+ *       <td>Group {groupIndex}</td>
+ *     </>
+ *   )}
+ * />
+ * ```
+ *
+ * @see {@link GroupedTableVirtuosoProps} for available props
+ * @see {@link GroupedTableVirtuosoHandle} for imperative methods
+ */
 export declare const GroupedTableVirtuoso: <ItemData = any, Context = any>(props: GroupedTableVirtuosoProps<ItemData, Context> & {
     ref?: default_2.Ref<GroupedTableVirtuosoHandle>;
 }) => default_2.ReactElement;
 
+/**
+ * Exposes the GroupedTableVirtuoso component methods for imperative control.
+ * Access via ref on the GroupedTableVirtuoso component.
+ *
+ * @see {@link GroupedTableVirtuoso} for the component
+ * @see {@link GroupedTableVirtuosoProps} for available props
+ * @group GroupedTableVirtuoso
+ */
 export declare interface GroupedTableVirtuosoHandle extends BaseTableVirtuosoHandle {
+    /**
+     * Scrolls the specified item into view if it's not already visible.
+     * @param location - The scroll into view location options
+     */
     scrollIntoView(location: ScrollIntoViewLocationOptions): void;
+    /**
+     * Scrolls the component to the specified item index.
+     * @param location - The item index or location with alignment options
+     */
     scrollToIndex(location: IndexLocationWithAlign | number): void;
 }
 
-export declare interface GroupedTableVirtuosoProps<D, C> extends Omit<TableVirtuosoProps<D, C>, 'itemContent' | 'totalCount'> {
+/**
+ * The props for the GroupedTableVirtuoso component.
+ *
+ * @typeParam Data - The type of data items in the table
+ * @typeParam Context - The type of additional context passed to callbacks
+ *
+ * @see {@link GroupedTableVirtuoso} for the component
+ * @see {@link GroupedTableVirtuosoHandle} for imperative methods
+ * @group GroupedTableVirtuoso
+ */
+export declare interface GroupedTableVirtuosoProps<Data, Context> extends Omit<TableVirtuosoProps<Data, Context>, 'itemContent' | 'totalCount'> {
     /**
      * Use when implementing inverse infinite scrolling, decrease the value this property
      * in combination with a change in `groupCounts` to prepend groups items to the top of the list.
@@ -223,7 +483,7 @@ export declare interface GroupedTableVirtuosoProps<D, C> extends Omit<TableVirtu
     /**
      * Specifies how each each group header gets rendered. The callback receives the zero-based index of the group.
      */
-    groupContent?: GroupContent<C>;
+    groupContent?: GroupContent<Context>;
     /**
      * Specifies the amount of items in each group (and, actually, how many groups are there).
      * For example, passing [20, 30] will display 2 groups with 20 and 30 items each.
@@ -232,26 +492,88 @@ export declare interface GroupedTableVirtuosoProps<D, C> extends Omit<TableVirtu
     /**
      * Specifies how each each item gets rendered.
      */
-    itemContent?: GroupItemContent<D, C>;
+    itemContent?: GroupItemContent<Data, Context>;
 }
 
+/**
+ * A virtualized list component for rendering grouped data with sticky group headers.
+ * Extends Virtuoso with support for collapsible groups and group-level navigation.
+ *
+ * @typeParam ItemData - The type of data items in the list
+ * @typeParam Context - The type of additional context passed to callbacks
+ *
+ * @param props - {@link GroupedVirtuosoProps}
+ *
+ * @function
+ * @group GroupedVirtuoso
+ *
+ * @example
+ * ```tsx
+ * <GroupedVirtuoso
+ *   groupCounts={[10, 20, 15]}
+ *   groupContent={(index) => <div>Group {index}</div>}
+ *   itemContent={(index, groupIndex) => <div>Item {index} in group {groupIndex}</div>}
+ * />
+ * ```
+ *
+ * @see {@link GroupedVirtuosoProps} for available props
+ * @see {@link GroupedVirtuosoHandle} for imperative methods
+ */
 export declare const GroupedVirtuoso: <ItemData = any, Context = any>(props: GroupedVirtuosoProps<ItemData, Context> & {
     ref?: default_2.Ref<GroupedVirtuosoHandle>;
 }) => default_2.ReactElement;
 
+/**
+ * Exposes the GroupedVirtuoso component methods for imperative control.
+ * Access via ref on the GroupedVirtuoso component.
+ *
+ * @see {@link GroupedVirtuoso} for the component
+ * @see {@link GroupedVirtuosoProps} for available props
+ * @group GroupedVirtuoso
+ */
 export declare interface GroupedVirtuosoHandle {
+    /**
+     * Scrolls to the bottom of the list if follow output is active. Useful when images load in the list.
+     */
     autoscrollToBottom(): void;
     /**
      * Obtains the internal size state of the component, so that it can be restored later. This does not include the data items.
+     * @param stateCb - Callback that receives the state snapshot
      */
     getState(stateCb: StateCallback): void;
+    /**
+     * Scrolls the component by the specified amount.
+     * @param location - The scroll offset options
+     */
     scrollBy(location: ScrollToOptions): void;
+    /**
+     * Scrolls the specified item into view if it's not already visible.
+     * @param location - The item index or scroll location options
+     */
     scrollIntoView(location: number | ScrollIntoViewLocation): void;
+    /**
+     * Scrolls the component to the specified position.
+     * @param location - The scroll position options
+     */
     scrollTo(location: ScrollToOptions): void;
+    /**
+     * Scrolls the component to the specified item index.
+     * @param location - The item index or location with alignment options
+     */
     scrollToIndex(location: IndexLocationWithAlign | number): void;
 }
 
-export declare interface GroupedVirtuosoProps<D, C> extends Omit<VirtuosoProps<D, C>, 'itemContent' | 'totalCount'> {
+/**
+ * The props for the GroupedVirtuoso component.
+ *
+ * @typeParam Data - The type of data items in the list
+ * @typeParam Context - The type of additional context passed to callbacks
+ *
+ * @see {@link GroupedVirtuoso} for the component
+ * @see {@link GroupedVirtuosoHandle} for imperative methods
+ * @group GroupedVirtuoso
+ */
+export declare interface GroupedVirtuosoProps<Data, Context> extends Omit<VirtuosoProps<Data, Context>, 'itemContent' | 'totalCount'> {
     /**
      * Use when implementing inverse infinite scrolling, decrease the value this property
      * in combination with a change in `groupCounts` to prepend groups items to the top of the list.
@@ -269,7 +591,7 @@ export declare interface GroupedVirtuosoProps<D, C> extends Omit<VirtuosoProps<D
     /**
      * Specifies how each each group header gets rendered. The callback receives the zero-based index of the group.
      */
-    groupContent?: GroupContent<C>;
+    groupContent?: GroupContent<Context>;
     /**
      * Specifies the amount of items in each group (and, actually, how many groups are there).
      * For example, passing [20, 30] will display 2 groups with 20 and 30 items each.
@@ -278,9 +600,12 @@ export declare interface GroupedVirtuosoProps<D, C> extends Omit<VirtuosoProps<D
     /**
      * Specifies how each each item gets rendered.
      */
-    itemContent?: GroupItemContent<D, C>;
+    itemContent?: GroupItemContent<Data, Context>;
 }
 
+/**
+ * @group GroupedVirtuoso
+ */
 export declare interface GroupIndexLocationWithAlign extends LocationOptions {
     /**
      * The group index of the item to scroll to.
@@ -288,54 +613,143 @@ export declare interface GroupIndexLocationWithAlign extends LocationOptions {
     groupIndex: number;
 }
 
-export declare interface GroupItem<D> extends Item<D> {
+/**
+ * @group GroupedVirtuoso
+ */
+export declare interface GroupItem<Data> extends Item<Data> {
+    /** The original index before any transformations were applied */
     originalIndex?: number;
+    /** Identifies this as a group header item */
     type: 'group';
 }
 
-export declare type GroupItemContent<D, C> = (index: number, groupIndex: number, data: D, context: C) => default_2.ReactNode;
+/**
+ * Callback type for rendering item content in a GroupedVirtuoso list.
+ * Similar to ItemContent but includes the group index.
+ *
+ * @typeParam Data - The type of the data item
+ * @typeParam Context - The type of context passed from the component
+ *
+ * @example
+ * ```tsx
+ * const itemContent: GroupItemContent<User, AppContext> = (index, groupIndex, user, context) => (
+ *   <div>{user.name} (Group {groupIndex})</div>
+ * )
+ * <GroupedVirtuoso itemContent={itemContent} />
+ * ```
+ *
+ * @see {@link GroupedVirtuosoProps.itemContent} for usage
+ * @see {@link ItemContent} for non-grouped list variant
+ * @group GroupedVirtuoso
+ */
+export declare type GroupItemContent<Data, Context> = (index: number, groupIndex: number, data: Data, context: Context) => default_2.ReactNode;
 
+/**
+ * Passed to the Components.Group custom component
+ * @group GroupedVirtuoso
+ */
 export declare type GroupProps = Pick<default_2.ComponentProps<'div'>, 'children' | 'style'> & {
+    /** The index of the group */
     'data-index': number;
+    /** The item index within the flattened list */
     'data-item-index': number;
+    /** The measured size of the group header in pixels */
     'data-known-size': number;
 };
 
+/**
+ * @group Common
+ */
 export declare type IndexLocationWithAlign = FlatIndexLocationWithAlign | GroupIndexLocationWithAlign;
 
-export declare interface Item<D> {
-    data?: D;
+/**
+ * Base interface for list items with position and size information.
+ * @group Common
+ */
+export declare interface Item<Data> {
+    /** The data associated with this item */
+    data?: Data;
+    /** The index of the item in the list */
     index: number;
+    /** The offset position of the item from the start of the list in pixels */
     offset: number;
+    /** The measured size of the item in pixels */
     size: number;
 }
 
-export declare type ItemContent<D, C> = (index: number, data: D, context: C) => default_2.ReactNode;
+/**
+ * Callback type for rendering item content in a Virtuoso list.
+ *
+ * @typeParam Data - The type of the data item
+ * @typeParam Context - The type of context passed from the component
+ *
+ * @example
+ * ```tsx
+ * const itemContent: ItemContent<User, AppContext> = (index, user, context) => (
+ *   <div>{user.name}</div>
+ * )
+ * <Virtuoso itemContent={itemContent} data={users} />
+ * ```
+ *
+ * @see {@link VirtuosoProps.itemContent} for usage in Virtuoso
+ * @see {@link GroupItemContent} for grouped list variant
+ * @group Virtuoso
+ */
+export declare type ItemContent<Data, Context> = (index: number, data: Data, context: Context) => default_2.ReactNode;
 
-export declare type ItemProps<D> = Pick<default_2.ComponentProps<'div'>, 'children' | 'style'> & {
+/**
+ * Passed to the Components.Item custom component
+ * @group Virtuoso
+ */
+export declare type ItemProps<Data> = Pick<default_2.ComponentProps<'div'>, 'children' | 'style'> & {
     'data-index': number;
     'data-item-group-index'?: number;
     'data-item-index': number;
     'data-known-size': number;
-    item: D;
+    item: Data;
 };
 
-export declare type ListItem<D> = GroupItem<D> | RecordItem<D>;
+/**
+ * Union type representing either a regular item or a group header item in the list.
+ *
+ * @typeParam Data - The type of the data item
+ *
+ * @see {@link RecordItem} for regular items
+ * @see {@link GroupItem} for group header items
+ * @group Common
+ */
+export declare type ListItem<Data> = GroupItem<Data> | RecordItem<Data>;
 
 /**
  * Passed to the Components.List custom component
+ * @group Virtuoso
  */
 export declare type ListProps = Pick<default_2.ComponentProps<'div'>, 'children' | 'style'> & default_2.RefAttributes<HTMLDivElement> & {
     'data-testid': string;
 };
 
+/**
+ * Represents a range of items in the list by their indices.
+ * Used to track which items are currently visible in the viewport.
+ *
+ * @see {@link VirtuosoProps.rangeChanged} for visibility change events
+ * @group Common
+ */
 export declare interface ListRange {
+    /** The index of the last visible item */
     endIndex: number;
+    /** The index of the first visible item */
     startIndex: number;
 }
 
+/**
+ * @group Virtuoso
+ */
 export declare type ListRootProps = Omit<default_2.HTMLProps<HTMLDivElement>, 'data' | 'ref'>;
 
+/**
+ * @group Common
+ */
 export declare interface LocationOptions {
     /**
      * How to position the item in the viewport.
@@ -351,38 +765,84 @@ export declare interface LocationOptions {
     offset?: number;
 }
 
+/**
+ * Log levels for controlling virtuoso diagnostic output.
+ * Use with the `logLevel` prop to enable debugging information.
+ *
+ * @example
+ * ```tsx
+ * import { Virtuoso, LogLevel } from 'react-virtuoso'
+ *
+ * <Virtuoso
+ *   totalCount={1000}
+ *   logLevel={LogLevel.DEBUG}
+ *   itemContent={(index) => <div>Item {index}</div>}
+ * />
+ * ```
+ *
+ * @group Common
+ */
 export declare enum LogLevel {
+    /** Detailed debugging information including item measurements */
     DEBUG = 0,
+    /** General informational messages */
     INFO = 1,
+    /** Warning messages for potential issues */
     WARN = 2,
+    /** Error messages for failures (default level) */
     ERROR = 3
 }
 
-export declare interface RecordItem<D> extends Item<D> {
-    data?: D;
+/**
+ * Represents a regular data item (not a group header) in the list.
+ * @group Common
+ */
+export declare interface RecordItem<Data> extends Item<Data> {
+    /** The data associated with this item */
+    data?: Data;
+    /** The index of the group this item belongs to (if in a grouped list) */
     groupIndex?: number;
+    /** The original index before any transformations were applied */
     originalIndex?: number;
+    /** Undefined for regular items (used to distinguish from group items) */
     type?: undefined;
 }
 
+/**
+ * Represents the current scroll state of the container.
+ * @group Common
+ */
 export declare interface ScrollContainerState {
+    /** The total scrollable height of the content in pixels */
     scrollHeight: number;
+    /** The current scroll position from the top in pixels */
     scrollTop: number;
+    /** The visible height of the viewport in pixels */
     viewportHeight: number;
 }
 
 /**
  * Passed to the Components.Scroller custom component
+ * @group Common
  */
 export declare type ScrollerProps = Pick<default_2.ComponentProps<'div'>, 'children' | 'style' | 'tabIndex'> & default_2.RefAttributes<HTMLDivElement> & {
     'data-testid'?: string;
     'data-virtuoso-scroller'?: boolean;
 };
 
+/**
+ * @group Common
+ */
 export declare type ScrollIntoViewLocation = FlatScrollIntoViewLocation | GroupedScrollIntoViewLocation;
 
+/**
+ * Options for scrolling an item into view.
+ * @group Common
+ */
 export declare interface ScrollIntoViewLocationOptions {
+    /** How to align the item within the viewport */
     align?: 'center' | 'end' | 'start';
+    /** The scroll behavior - 'smooth' for animated scrolling, 'auto' for instant */
     behavior?: 'auto' | 'smooth';
     /**
      * Use this function to fine-tune the scrollIntoView behavior.
@@ -414,9 +874,27 @@ export declare interface ScrollIntoViewLocationOptions {
     done?: () => void;
 }
 
+/**
+ * Configuration for scroll seek mode, which renders placeholders during fast scrolling.
+ * This improves performance when users scroll rapidly through large lists.
+ *
+ * @example
+ * ```tsx
+ * const scrollSeekConfiguration: ScrollSeekConfiguration = {
+ *   enter: (velocity) => Math.abs(velocity) > 200,
+ *   exit: (velocity) => Math.abs(velocity) < 30,
+ *   change: (velocity, range) => console.log('Scrolling', range),
+ * }
+ * <Virtuoso scrollSeekConfiguration={scrollSeekConfiguration} />
+ * ```
+ *
+ * @see {@link VirtuosoProps.scrollSeekConfiguration} for usage
+ * @see {@link Components.ScrollSeekPlaceholder} for custom placeholder rendering
+ * @group Common
+ */
 export declare interface ScrollSeekConfiguration {
     /**
-     * called during scrolling in scroll seek mode - use to display a hint where the list is.
+     * Called during scrolling in scroll seek mode - use to display a hint where the list is.
      */
     change?: (velocity: number, range: ListRange) => void;
     /**
@@ -431,34 +909,73 @@ export declare interface ScrollSeekConfiguration {
 
 /**
  * Passed to the Components.ScrollSeekPlaceholder custom component
+ * @group Virtuoso
  */
 export declare interface ScrollSeekPlaceholderProps {
+    /** The group index if this placeholder represents a group header */
     groupIndex?: number;
+    /** The height of the placeholder in pixels */
     height: number;
+    /** The index of the item being replaced by the placeholder */
     index: number;
+    /** Whether this placeholder represents a group header or a regular item */
     type: 'group' | 'item';
 }
 
+/**
+ * @group Common
+ */
 export declare type ScrollSeekToggle = (velocity: number, range: ListRange) => boolean;
 
-/** Calculates the height of `el`, which will be the `Item` element in the DOM. */
+/**
+ * Custom function for calculating item sizes.
+ * Override to account for margins, padding, or other layout considerations.
+ *
+ * @see {@link VirtuosoProps.itemSize} for usage
+ * @group Common
+ */
 export declare type SizeFunction = (el: HTMLElement, field: 'offsetHeight' | 'offsetWidth') => number;
 
+/**
+ * Represents a range of items that share the same size.
+ * @group Common
+ */
 export declare interface SizeRange {
+    /** The ending index of items in this size range (inclusive) */
     endIndex: number;
+    /** The size in pixels shared by items in this range */
     size: number;
+    /** The starting index of items in this size range */
     startIndex: number;
 }
 
+/**
+ * Callback type for receiving state snapshots for persistence.
+ *
+ * @see {@link VirtuosoProps.getState} for usage
+ * @see {@link StateSnapshot} for the snapshot structure
+ * @group Common
+ */
 export declare type StateCallback = (state: StateSnapshot) => void;
 
+/**
+ * A snapshot of the virtuoso state that can be saved and restored.
+ * Use this to persist scroll position and item sizes across page reloads.
+ *
+ * @see {@link VirtuosoProps.restoreStateFrom} for restoring state
+ * @see {@link VirtuosoHandle.getState} for capturing state
+ * @group Common
+ */
 export declare interface StateSnapshot {
+    /** The measured size ranges of items */
     ranges: SizeRange[];
+    /** The scroll position in pixels */
     scrollTop: number;
 }
 
 /**
- * Passed to the Components.TableBody custom component
+ * Passed to the TableComponents.TableBody custom component
+ * @group TableVirtuoso
  */
 export declare type TableBodyProps = Pick<default_2.ComponentProps<'tbody'>, 'children' | 'className' | 'style'> & default_2.RefAttributes<HTMLTableSectionElement> & {
     'data-testid': string;
@@ -466,6 +983,21 @@ export declare type TableBodyProps = Pick<default_2.ComponentProps<'tbody'>, 'ch
 
 /**
  * Customize the TableVirtuoso rendering by passing a set of custom components.
+ *
+ * @typeParam Data - The type of data items in the table
+ * @typeParam Context - The type of additional context passed to components
+ *
+ * @example
+ * ```tsx
+ * const components: TableComponents<User, AppContext> = {
+ *   Table: ({ children, style }) => <table style={style}>{children}</table>,
+ *   TableRow: ({ children, item }) => <tr>{children}</tr>,
+ * }
+ * <TableVirtuoso components={components} />
+ * ```
+ *
+ * @see {@link TableVirtuosoProps.components} for usage in TableVirtuoso
+ * @group TableVirtuoso
  */
 export declare interface TableComponents<Data = unknown, Context = unknown> {
     /**
@@ -513,20 +1045,88 @@ export declare interface TableComponents<Data = unknown, Context = unknown> {
     TableRow?: default_2.ComponentType<ItemProps<Data> & ContextProp<Context>>;
 }
 
+/**
+ * @group TableVirtuoso
+ */
 export declare type TableProps = Pick<default_2.ComponentProps<'table'>, 'children' | 'style'>;
 
+/**
+ * @group TableVirtuoso
+ */
 export declare type TableRootProps = Omit<default_2.HTMLProps<HTMLTableElement>, 'data' | 'ref'>;
 
+/**
+ * A virtualized table component for efficiently rendering large tabular datasets.
+ * Renders semantic HTML table markup with support for fixed headers and footers.
+ *
+ * @typeParam ItemData - The type of data items in the table
+ * @typeParam Context - The type of additional context passed to callbacks
+ *
+ * @param props - {@link TableVirtuosoProps}
+ *
+ * @function
+ * @group TableVirtuoso
+ *
+ * @example
+ * ```tsx
+ * <TableVirtuoso
+ *   totalCount={1000}
+ *   fixedHeaderContent={() => (
+ *     <tr>
+ *       <th>Name</th>
+ *       <th>Description</th>
+ *     </tr>
+ *   )}
+ *   itemContent={(index) => (
+ *     <>
+ *       <td>Item {index}</td>
+ *       <td>Description {index}</td>
+ *     </>
+ *   )}
+ * />
+ * ```
+ *
+ * @see {@link TableVirtuosoProps} for available props
+ * @see {@link TableVirtuosoHandle} for imperative methods
+ * @see {@link TableComponents} for customizing table elements
+ */
 export declare const TableVirtuoso: <ItemData = any, Context = any>(props: TableVirtuosoProps<ItemData, Context> & {
     ref?: default_2.Ref<TableVirtuosoHandle>;
 }) => default_2.ReactElement;
 
+/**
+ * Exposes the TableVirtuoso component methods for imperative control.
+ * Access via ref on the TableVirtuoso component.
+ *
+ * @see {@link TableVirtuoso} for the component
+ * @see {@link TableVirtuosoProps} for available props
+ * @group TableVirtuoso
+ */
 export declare interface TableVirtuosoHandle extends BaseTableVirtuosoHandle {
+    /**
+     * Scrolls the specified item into view if it's not already visible.
+     * @param location - The item index or scroll into view location options
+     */
     scrollIntoView(location: FlatScrollIntoViewLocation | number): void;
+    /**
+     * Scrolls the component to the specified item index.
+     * @param location - The item index or location with alignment options
+     */
     scrollToIndex(location: FlatIndexLocationWithAlign | number): void;
 }
 
-export declare interface TableVirtuosoProps<D, C> extends Omit<VirtuosoProps<D, C>, 'components' | 'headerFooterTag'> {
+/**
+ * The props for the TableVirtuoso component.
+ *
+ * @typeParam Data - The type of data items in the table
+ * @typeParam Context - The type of additional context passed to callbacks
+ *
+ * @see {@link TableVirtuoso} for the component
+ * @see {@link TableVirtuosoHandle} for imperative methods
+ * @see {@link TableComponents} for customizing table elements
+ * @group TableVirtuoso
+ */
+export declare interface TableVirtuosoProps<Data, Context> extends Omit<VirtuosoProps<Data, Context>, 'components' | 'headerFooterTag'> {
     /**
      * Setting `alignToBottom` to `true` aligns the items to the bottom of the list if the list is shorter than the viewport.
      * Use `followOutput` property to keep the list aligned when new items are appended.
@@ -552,11 +1152,11 @@ export declare interface TableVirtuosoProps<D, C> extends Omit<VirtuosoProps<D,
     /**
      * Use the `components` property for advanced customization of the elements rendered by the table.
      */
-    components?: TableComponents<D, C>;
+    components?: TableComponents<Data, Context>;
     /**
      * If specified, the component will use the function to generate the `key` property for each list item.
      */
-    computeItemKey?: ComputeItemKey<D, C>;
+    computeItemKey?: ComputeItemKey<Data, Context>;
     /**
      * Pass a reference to a scrollable parent element, so that the table won't wrap in its own.
      */
@@ -564,7 +1164,7 @@ export declare interface TableVirtuosoProps<D, C> extends Omit<VirtuosoProps<D,
     /**
      * The data items to be rendered. If data is set, the total count will be inferred from the length of the array.
      */
-    data?: readonly D[];
+    data?: readonly Data[];
     /**
      * By default, the component assumes the default item height from the first rendered item (rendering it as a "probe").
      *
@@ -661,7 +1261,7 @@ export declare interface TableVirtuosoProps<D, C> extends Omit<VirtuosoProps<D,
     /**
      * Set the callback to specify the contents of the item.
      */
-    itemContent?: ItemContent<D, C>;
+    itemContent?: ItemContent<Data, Context>;
     /**
      * Allows customizing the height/width calculation of `Item` elements.
      *
@@ -671,7 +1271,7 @@ export declare interface TableVirtuosoProps<D, C> extends Omit<VirtuosoProps<D,
     /**
      * Called with the new set of items each time the list items are rendered due to scrolling.
      */
-    itemsRendered?: (items: ListItem<D>[]) => void;
+    itemsRendered?: (items: ListItem<Data>[]) => void;
     /**
      * Set the overscan property to make the component "chunk" the rendering of new items on scroll.
      * The property causes the component to render more items than the necessary, but reduces the re-renders on scroll.
@@ -724,32 +1324,140 @@ export declare interface TableVirtuosoProps<D, C> extends Omit<VirtuosoProps<D,
     useWindowScroll?: boolean;
 }
 
+/**
+ * @group Virtuoso
+ */
 export declare type TopItemListProps = Pick<default_2.ComponentProps<'div'>, 'children' | 'style'>;
 
+/**
+ * A virtualized list component for efficiently rendering large datasets.
+ * Automatically measures and handles variable-sized items without configuration.
+ *
+ * @typeParam ItemData - The type of data items in the list
+ * @typeParam Context - The type of additional context passed to callbacks
+ *
+ * @param props - {@link VirtuosoProps}
+ *
+ * @function
+ * @group Virtuoso
+ *
+ * @example
+ * ```tsx
+ * <Virtuoso
+ *   totalCount={1000}
+ *   itemContent={(index) => <div>Item {index}</div>}
+ * />
+ * ```
+ *
+ * @see {@link VirtuosoProps} for available props
+ * @see {@link VirtuosoHandle} for imperative methods
+ */
 export declare const Virtuoso: <ItemData = any, Context = any>(props: VirtuosoProps<ItemData, Context> & {
     ref?: default_2.Ref<VirtuosoHandle>;
 }) => default_2.ReactElement;
 
+/**
+ * A virtualized grid component for efficiently rendering large datasets in a grid/masonry layout.
+ * Automatically calculates visible items based on container and item dimensions.
+ *
+ * @typeParam ItemData - The type of data items in the grid
+ * @typeParam Context - The type of additional context passed to callbacks
+ *
+ * @param props - {@link VirtuosoGridProps}
+ *
+ * @function
+ * @group VirtuosoGrid
+ *
+ * @example
+ * ```tsx
+ * <VirtuosoGrid
+ *   totalCount={1000}
+ *   itemContent={(index) => <div className="grid-item">Item {index}</div>}
+ *   listClassName="grid-container"
+ * />
+ * ```
+ *
+ * @see {@link VirtuosoGridProps} for available props
+ * @see {@link VirtuosoGridHandle} for imperative methods
+ * @see {@link GridComponents} for customizing grid elements
+ */
 export declare const VirtuosoGrid: <ItemData = any, Context = any>(props: VirtuosoGridProps<ItemData, Context> & {
     ref?: default_2.Ref<VirtuosoGridHandle>;
 }) => default_2.ReactElement;
 
+/**
+ * Exposes the VirtuosoGrid component methods for imperative control.
+ * Access via ref on the VirtuosoGrid component.
+ *
+ * @see {@link VirtuosoGrid} for the component
+ * @see {@link VirtuosoGridProps} for available props
+ * @group VirtuosoGrid
+ */
 export declare interface VirtuosoGridHandle {
+    /**
+     * Scrolls the component by the specified amount.
+     * @param location - The scroll offset options
+     */
     scrollBy(location: ScrollToOptions): void;
+    /**
+     * Scrolls the component to the specified position.
+     * @param location - The scroll position options
+     */
     scrollTo(location: ScrollToOptions): void;
+    /**
+     * Scrolls the component to the specified item index.
+     * @param location - The item index or location with alignment options
+     */
     scrollToIndex(location: GridIndexLocation): void;
 }
 
+/**
+ * React context for mocking VirtuosoGrid component measurements in tests.
+ * Wrap your VirtuosoGrid component with this provider to bypass DOM measurements.
+ *
+ * @example
+ * ```tsx
+ * import { VirtuosoGridMockContext } from 'react-virtuoso'
+ *
+ * <VirtuosoGridMockContext.Provider
+ *   value={{ viewportHeight: 300, viewportWidth: 400, itemHeight: 100, itemWidth: 100 }}
+ * >
+ *   <VirtuosoGrid totalCount={100} />
+ * </VirtuosoGridMockContext.Provider>
+ * ```
+ *
+ * @group VirtuosoGrid
+ */
 export declare const VirtuosoGridMockContext: default_2.Context<VirtuosoGridMockContextValue | undefined>;
 
+/**
+ * Mock context value for testing VirtuosoGrid components.
+ * Provides fixed dimensions to bypass DOM measurements.
+ *
+ * @group VirtuosoGrid
+ */
 export declare interface VirtuosoGridMockContextValue {
+    /** Fixed height for each grid item in pixels */
     itemHeight: number;
+    /** Fixed width for each grid item in pixels */
     itemWidth: number;
+    /** Fixed viewport height in pixels */
     viewportHeight: number;
+    /** Fixed viewport width in pixels */
     viewportWidth: number;
 }
 
-export declare interface VirtuosoGridProps<D, C = unknown> extends GridRootProps {
+/**
+ * The props for the VirtuosoGrid component.
+ *
+ * @typeParam Data - The type of data items in the grid
+ * @typeParam Context - The type of additional context passed to callbacks
+ *
+ * @see {@link VirtuosoGrid} for the component
+ * @see {@link VirtuosoGridHandle} for imperative methods
+ * @group VirtuosoGrid
+ */
+export declare interface VirtuosoGridProps<Data, Context = unknown> extends GridRootProps {
     /**
      * Called with true / false when the list has reached the bottom / gets scrolled up.
      * Can be used to load newer items, like `tail -f`.
@@ -762,15 +1470,15 @@ export declare interface VirtuosoGridProps<D, C = unknown> extends GridRootProps
     /**
      * Use the `components` property for advanced customization of the elements rendered by the list.
      */
-    components?: GridComponents<C>;
+    components?: GridComponents<Context>;
     /**
      * If specified, the component will use the function to generate the `key` property for each list item.
      */
-    computeItemKey?: GridComputeItemKey<D, C>;
+    computeItemKey?: GridComputeItemKey<Data, Context>;
     /**
      * Additional context available in the custom components and content callbacks
      */
-    context?: C;
+    context?: Context;
     /**
      * Pass a reference to a scrollable parent element, so that the grid won't wrap in its own.
      */
@@ -778,7 +1486,7 @@ export declare interface VirtuosoGridProps<D, C = unknown> extends GridRootProps
     /**
      * The data items to be rendered. If data is set, the total count will be inferred from the length of the array.
      */
-    data?: readonly D[];
+    data?: readonly Data[];
     /**
      * Gets called when the user scrolls to the end of the list.
      * Receives the last item index as an argument. Can be used to implement endless scrolling.
@@ -802,6 +1510,10 @@ export declare interface VirtuosoGridProps<D, C = unknown> extends GridRootProps
      * regardless of the container / item size.
      */
     initialItemCount?: number;
+    /**
+     * Set to a value between 0 and totalCount - 1 to make the grid start scrolled to that item.
+     * Pass in an object to achieve additional effects similar to `scrollToIndex`.
+     */
     initialTopMostItemIndex?: GridIndexLocation;
     /**
      * Called when the list starts/stops scrolling.
@@ -814,7 +1526,7 @@ export declare interface VirtuosoGridProps<D, C = unknown> extends GridRootProps
     /**
      * Set the callback to specify the contents of the item.
      */
-    itemContent?: GridItemContent<D, C>;
+    itemContent?: GridItemContent<Data, Context>;
     /**
      * Sets the className for the list DOM element
      */
@@ -843,6 +1555,10 @@ export declare interface VirtuosoGridProps<D, C = unknown> extends GridRootProps
      * invoked with true after the grid has done the initial render and the items have been measured.
      */
     readyStateChanged?: (ready: boolean) => void;
+    /**
+     * Pass a state obtained from the `stateChanged` callback to restore the grid state.
+     * This includes scroll position and item measurements.
+     */
     restoreStateFrom?: GridStateSnapshot | null | undefined;
     /**
      * Provides access to the root DOM element
@@ -872,6 +1588,14 @@ export declare interface VirtuosoGridProps<D, C = unknown> extends GridRootProps
     useWindowScroll?: boolean;
 }
 
+/**
+ * Exposes the Virtuoso component methods for imperative control.
+ * Access via ref on the Virtuoso component.
+ *
+ * @see {@link Virtuoso} for the component
+ * @see {@link VirtuosoProps} for available props
+ * @group Virtuoso
+ */
 export declare interface VirtuosoHandle {
     /**
      * Use this with combination with follow output if you have images loading in the list. Listen to the image loading and call the method.
@@ -879,34 +1603,72 @@ export declare interface VirtuosoHandle {
     autoscrollToBottom(): void;
     /**
      * Obtains the internal size state of the component, so that it can be restored later. This does not include the data items.
+     * @param stateCb - Callback that receives the state snapshot
      */
     getState(stateCb: StateCallback): void;
     /**
      * Scrolls the component with the specified amount. See [ScrollToOptions (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/ScrollToOptions)
+     * @param location - The scroll offset options
      */
     scrollBy(location: ScrollToOptions): void;
     /**
      * Scrolls the item into view if necessary. See [the website example](http://virtuoso.dev/keyboard-navigation/) for an implementation.
+     * @param location - The scroll into view location options
      */
     scrollIntoView(location: FlatScrollIntoViewLocation): void;
     /**
      * Scrolls the component to the specified location. See [ScrollToOptions (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/ScrollToOptions)
+     * @param location - The scroll position options
      */
     scrollTo(location: ScrollToOptions): void;
     /**
      * Scrolls the component to the specified item index. See {@link IndexLocationWithAlign} for more options.
+     * @param location - The item index or location with alignment options
      */
     scrollToIndex(location: FlatIndexLocationWithAlign | number): void;
 }
 
+/**
+ * React context for mocking Virtuoso component measurements in tests.
+ * Wrap your Virtuoso component with this provider to bypass DOM measurements.
+ *
+ * @example
+ * ```tsx
+ * import { VirtuosoMockContext } from 'react-virtuoso'
+ *
+ * <VirtuosoMockContext.Provider value={{ viewportHeight: 300, itemHeight: 30 }}>
+ *   <Virtuoso totalCount={100} />
+ * </VirtuosoMockContext.Provider>
+ * ```
+ *
+ * @group Virtuoso
+ */
 export declare const VirtuosoMockContext: default_2.Context<VirtuosoMockContextValue | undefined>;
 
+/**
+ * Mock context value for testing Virtuoso components.
+ * Provides fixed dimensions to bypass DOM measurements.
+ *
+ * @group Virtuoso
+ */
 export declare interface VirtuosoMockContextValue {
+    /** Fixed height for each item in pixels */
     itemHeight: number;
+    /** Fixed viewport height in pixels */
     viewportHeight: number;
 }
 
-export declare interface VirtuosoProps<D, C> extends ListRootProps {
+/**
+ * The props for the Virtuoso component.
+ *
+ * @typeParam Data - The type of data items in the list
+ * @typeParam Context - The type of additional context passed to callbacks
+ *
+ * @see {@link Virtuoso} for the component
+ * @see {@link VirtuosoHandle} for imperative methods
+ * @group Virtuoso
+ */
+export declare interface VirtuosoProps<Data, Context> extends ListRootProps {
     /**
      * Setting `alignToBottom` to `true` aligns the items to the bottom of the list if the list is shorter than the viewport.
      * Use `followOutput` property to keep the list aligned when new items are appended.
@@ -936,15 +1698,15 @@ export declare interface VirtuosoProps<D, C> extends ListRootProps {
     /**
      * Use the `components` property for advanced customization of the elements rendered by the list.
      */
-    components?: Components<D, C>;
+    components?: Components<Data, Context>;
     /**
      * If specified, the component will use the function to generate the `key` property for each list item.
      */
-    computeItemKey?: ComputeItemKey<D, C>;
+    computeItemKey?: ComputeItemKey<Data, Context>;
     /**
      * Additional context available in the custom components and content callbacks
      */
-    context?: C;
+    context?: Context;
     /**
      * Pass a reference to a scrollable parent element, so that the list won't wrap in its own.
      */
@@ -952,7 +1714,7 @@ export declare interface VirtuosoProps<D, C> extends ListRootProps {
     /**
      * The data items to be rendered. If data is set, the total count will be inferred from the length of the array.
      */
-    data?: readonly D[];
+    data?: readonly Data[];
     /**
      * By default, the component assumes the default item height from the first rendered item (rendering it as a "probe").
      *
@@ -1030,10 +1792,10 @@ export declare interface VirtuosoProps<D, C> extends ListRootProps {
      * Use the context contents if you need to implement custom logic based on the current state of the list.
      */
     scrollIntoViewOnChange?: (params: {
-        context: C;
+        context: Context;
         totalCount: number;
         scrollingInProgress: boolean;
-    }) => ScrollIntoViewLocation | null | undefined | false | void;
+    }) => ScrollIntoViewLocation | null | undefined | false;
     /**
      * Set to customize the wrapper tag for the header and footer components (default is `div`).
      */
@@ -1088,7 +1850,7 @@ export declare interface VirtuosoProps<D, C> extends ListRootProps {
     /**
      * Set the callback to specify the contents of the item.
      */
-    itemContent?: ItemContent<D, C>;
+    itemContent?: ItemContent<Data, Context>;
     /**
      * Allows customizing the height/width calculation of `Item` elements.
      *
@@ -1098,7 +1860,7 @@ export declare interface VirtuosoProps<D, C> extends ListRootProps {
     /**
      * Called with the new set of items each time the list items are rendered due to scrolling.
      */
-    itemsRendered?: (items: ListItem<D>[]) => void;
+    itemsRendered?: (items: ListItem<Data>[]) => void;
     /**
      * set to LogLevel.DEBUG to enable various diagnostics in the console, the most useful being the item measurement reports.
      *
@@ -1168,9 +1930,16 @@ export declare interface VirtuosoProps<D, C> extends ListRootProps {
     useWindowScroll?: boolean;
 }
 
+/**
+ * Information about the window viewport when using window scrolling mode.
+ * @group Common
+ */
 export declare interface WindowViewportInfo {
+    /** The offset from the top of the document to the list container in pixels */
     offsetTop: number;
+    /** The visible height of the window viewport in pixels */
     visibleHeight: number;
+    /** The visible width of the window viewport in pixels */
     visibleWidth: number;
 }