@legendapp/list 2.0.0-next.2 → 2.0.0-next.20

package/{dist/index.d.ts → index.d.ts}

@@ -1,11 +1,11 @@
+import * as _legendapp_list_reanimated from '@legendapp/list/reanimated';
 import * as React$1 from 'react';
 import { ComponentProps, ReactNode, Dispatch, SetStateAction } from 'react';
 import * as react_native from 'react-native';
-import { View, ScrollView, Animated, StyleProp, ViewStyle, ScrollViewProps, LayoutRectangle, NativeSyntheticEvent, NativeScrollEvent, ScrollViewComponent, ScrollResponderMixin } from 'react-native';
+import { View, Animated, ScrollView, StyleProp, ViewStyle, ScrollViewProps, LayoutRectangle, ScrollViewComponent, ScrollResponderMixin } from 'react-native';
 import Animated$1 from 'react-native-reanimated';
-import * as _legendapp_list_reanimated from '@legendapp/list/reanimated';
 
-type ListenerType = "numContainers" | "numContainersPooled" | `containerItemKey${number}` | `containerItemData${number}` | `containerPosition${number}` | `containerColumn${number}` | "containersDidLayout" | "extraData" | "numColumns" | "lastItemKeys" | "totalSize" | "alignItemsPaddingTop" | "stylePaddingTop" | "scrollAdjust" | "scrollAdjustUserOffset" | "headerSize" | "footerSize" | "maintainVisibleContentPosition" | "debugRawScroll" | "debugComputedScroll" | "otherAxisSize" | "scrollSize";
+type ListenerType = "numContainers" | "numContainersPooled" | `containerItemKey${number}` | `containerItemData${number}` | `containerPosition${number}` | `containerColumn${number}` | `containerSticky${number}` | `containerStickyOffset${number}` | "containersDidLayout" | "extraData" | "numColumns" | "lastItemKeys" | "totalSize" | "alignItemsPaddingTop" | "stylePaddingTop" | "scrollAdjust" | "scrollAdjustUserOffset" | "headerSize" | "footerSize" | "maintainVisibleContentPosition" | "debugRawScroll" | "debugComputedScroll" | "otherAxisSize" | "snapToOffsets" | "scrollSize";
 interface StateContext {
     listeners: Map<ListenerType, Set<(value: any) => void>>;
     values: Map<ListenerType, any>;
@@ -15,6 +15,7 @@ interface StateContext {
     mapViewabilityAmountValues: Map<number, ViewAmountToken>;
     columnWrapperStyle: ColumnWrapperStyle | undefined;
     viewRefs: Map<number, React$1.RefObject<View>>;
+    animatedScrollY: Animated.Value;
 }
 
 declare class ScrollAdjustHandler {
@@ -26,7 +27,7 @@ declare class ScrollAdjustHandler {
     setMounted(): void;
 }
 
-type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof ScrollView> | ComponentProps<typeof Animated.ScrollView> | ComponentProps<typeof Animated$1.ScrollView>> = Omit<TScrollView, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
+type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof ScrollView> | ComponentProps<typeof Animated.ScrollView> | ComponentProps<typeof Animated$1.ScrollView>, TItemType extends string | undefined = string | undefined> = Omit<TScrollView, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
     /**
      * If true, aligns items at the end of the list.
      * @default false
@@ -68,7 +69,7 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
      * In case you have distinct item sizes, you can provide a function to get the size of an item.
      * Use instead of FlatList's getItemLayout or FlashList overrideItemLayout if you want to have accurate initialScrollOffset, you should provide this function
      */
-    getEstimatedItemSize?: (index: number, item: ItemT) => number;
+    getEstimatedItemSize?: (index: number, item: ItemT, type: TItemType) => number;
     /**
      * Ratio of initial container pool size to data length (e.g., 0.5 for half).
      * @default 2
@@ -204,7 +205,7 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
      * - A React component: React.ComponentType<LegendListRenderItemProps<ItemT>>
      * @required
      */
-    renderItem?: ((props: LegendListRenderItemProps<ItemT>) => ReactNode) | React.ComponentType<LegendListRenderItemProps<ItemT>>;
+    renderItem?: ((props: LegendListRenderItemProps<ItemT, TItemType>) => ReactNode) | React.ComponentType<LegendListRenderItemProps<ItemT, TItemType>>;
     /**
      * Render custom ScrollView component.
      * @default (props) => <ScrollView {...props} />
@@ -232,6 +233,17 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
     onLoad?: (info: {
         elapsedTimeInMs: number;
     }) => void;
+    snapToIndices?: number[];
+    /**
+     * Array of child indices determining which children get docked to the top of the screen when scrolling.
+     * For example, passing stickyIndices={[0]} will cause the first child to be fixed to the top of the scroll view.
+     * Not supported in conjunction with horizontal={true}.
+     * @default undefined
+     */
+    stickyIndices?: number[];
+    getItemType?: (item: ItemT, index: number) => TItemType;
+    getFixedItemSize?: (index: number, item: ItemT, type: TItemType) => number;
+    itemsAreEqual?: (itemPrevious: ItemT, item: ItemT, index: number, data: readonly ItemT[]) => boolean;
 };
 interface MaintainScrollAtEndOptions {
     onLayout?: boolean;
@@ -243,13 +255,14 @@ interface ColumnWrapperStyle {
     gap?: number;
     columnGap?: number;
 }
-type LegendListProps<ItemT> = LegendListPropsBase<ItemT, Omit<ComponentProps<typeof ScrollView>, "scrollEventThrottle">>;
+type LegendListProps<ItemT = any> = LegendListPropsBase<ItemT, Omit<ComponentProps<typeof ScrollView>, "scrollEventThrottle">>;
 interface InternalState {
     positions: Map<string, number>;
     columns: Map<string, number>;
     sizes: Map<string, number>;
     sizesKnown: Map<string, number>;
     containerItemKeys: Set<string>;
+    containerItemTypes: Map<number, string>;
     pendingAdjust: number;
     isStartReached: boolean;
     isEndReached: boolean;
@@ -263,7 +276,6 @@ interface InternalState {
     endBuffered: number;
     endNoBuffer: number;
     firstFullyOnScreenIndex: number;
-    idsInView: string[];
     scrollPending: number;
     scroll: number;
     scrollTime: number;
@@ -315,48 +327,55 @@ interface InternalState {
     loadStartTime: number;
     initialScroll: ScrollIndexWithOffsetPosition | undefined;
     lastLayout: LayoutRectangle | undefined;
+    queuedItemSizeUpdates: {
+        itemKey: string;
+        sizeObj: {
+            width: number;
+            height: number;
+        };
+    }[];
+    queuedItemSizeUpdatesWaiting?: boolean;
+    timeoutSetPaddingTop?: any;
+    activeStickyIndex: number | undefined;
+    stickyContainers: Map<number, number>;
+    stickyContainerPool: Set<number>;
+    scrollProcessingEnabled: boolean;
     props: {
         alignItemsAtEnd: boolean;
         data: readonly any[];
         estimatedItemSize: number | undefined;
-        getEstimatedItemSize: ((index: number, item: any) => number) | undefined;
+        getEstimatedItemSize: LegendListProps["getEstimatedItemSize"];
+        getFixedItemSize: LegendListProps["getFixedItemSize"];
+        getItemType: LegendListProps["getItemType"];
         horizontal: boolean;
-        keyExtractor: ((item: any, index: number) => string) | undefined;
+        keyExtractor: LegendListProps["keyExtractor"];
         maintainScrollAtEnd: boolean | MaintainScrollAtEndOptions;
         maintainScrollAtEndThreshold: number | undefined;
         maintainVisibleContentPosition: boolean;
-        onEndReached: (((info: {
-            distanceFromEnd: number;
-        }) => void) | null | undefined) | undefined;
+        onEndReached: LegendListProps["onEndReached"];
         onEndReachedThreshold: number | null | undefined;
-        onItemSizeChanged: ((info: {
-            size: number;
-            previous: number;
-            index: number;
-            itemKey: string;
-            itemData: any;
-        }) => void) | undefined;
-        onLoad: ((info: {
-            elapsedTimeInMs: number;
-        }) => void) | undefined;
-        onScroll: ((event: NativeSyntheticEvent<NativeScrollEvent>) => void) | undefined;
-        onStartReached: (((info: {
-            distanceFromStart: number;
-        }) => void) | null | undefined) | undefined;
+        onItemSizeChanged: LegendListProps["onItemSizeChanged"];
+        onLoad: LegendListProps["onLoad"];
+        onScroll: LegendListProps["onScroll"];
+        onStartReached: LegendListProps["onStartReached"];
         onStartReachedThreshold: number | null | undefined;
+        recycleItems: boolean;
         suggestEstimatedItemSize: boolean;
         stylePaddingBottom: number | undefined;
-        renderItem: ((props: LegendListRenderItemProps<any>) => ReactNode) | React.ComponentType<LegendListRenderItemProps<any>>;
+        renderItem: LegendListProps["renderItem"];
         initialScroll: {
             index: number;
             viewOffset?: number;
             viewPosition?: number;
         } | undefined;
         scrollBuffer: number;
-        viewabilityConfigCallbackPairs: ViewabilityConfigCallbackPairs | undefined;
         numColumns: number;
         initialContainerPoolRatio: number;
         stylePaddingTop: number | undefined;
+        snapToIndices: number[] | undefined;
+        stickyIndicesSet: Set<number>;
+        stickyIndicesArr: number[];
+        itemsAreEqual: LegendListProps["itemsAreEqual"];
     };
 }
 interface ViewableRange<T> {
@@ -366,23 +385,27 @@ interface ViewableRange<T> {
     end: number;
     items: T[];
 }
-interface LegendListRenderItemProps<ItemT> {
+interface LegendListRenderItemProps<ItemT, TItemType extends string | number | undefined = string | number | undefined> {
     item: ItemT;
+    type: TItemType;
     index: number;
     extraData: any;
 }
 type ScrollState = {
     contentLength: number;
+    data: readonly any[];
     end: number;
     endBuffered: number;
     isAtEnd: boolean;
     isAtStart: boolean;
+    positionAtIndex: (index: number) => number;
+    positions: Map<string, number>;
     scroll: number;
     scrollLength: number;
+    sizeAtIndex: (index: number) => number;
+    sizes: Map<string, number>;
     start: number;
     startBuffered: number;
-    sizes: Map<string, number>;
-    sizeAtIndex: (index: number) => number;
 };
 type LegendListRef = {
     /**
@@ -429,9 +452,11 @@ type LegendListRef = {
      * Scrolls to the end of the list.
      * @param options - Options for scrolling.
      * @param options.animated - If true, animates the scroll. Default: true.
+     * @param options.viewOffset - Offset from the target position.
      */
     scrollToEnd(options?: {
         animated?: boolean | undefined;
+        viewOffset?: number | undefined;
     }): void;
     /**
      * Scrolls to a specific index in the list.
@@ -477,6 +502,11 @@ type LegendListRef = {
      * @param animated - If true, uses Animated to animate the change.
      */
     setVisibleContentAnchorOffset(value: number | ((value: number) => number)): void;
+    /**
+     * Sets whether scroll processing is enabled.
+     * @param enabled - If true, scroll processing is enabled.
+     */
+    setScrollProcessingEnabled(enabled: boolean): void;
 };
 interface ViewToken<ItemT = any> {
     item: ItemT;
@@ -540,7 +570,7 @@ interface LegendListRecyclingState<T> {
 }
 type TypedForwardRef = <T, P = {}>(render: (props: P, ref: React.Ref<T>) => React.ReactNode) => (props: P & React.RefAttributes<T>) => React.ReactNode;
 declare const typedForwardRef: TypedForwardRef;
-type TypedMemo = <T extends React.ComponentType<any>>(Component: T, propsAreEqual?: (prevProps: Readonly<ComponentProps<T>>, nextProps: Readonly<ComponentProps<T>>) => boolean) => T & {
+type TypedMemo = <T extends React.ComponentType<any>>(Component: T, propsAreEqual?: (prevProps: Readonly<React.JSXElementConstructor<T>>, nextProps: Readonly<React.JSXElementConstructor<T>>) => boolean) => T & {
     displayName?: string;
 };
 declare const typedMemo: TypedMemo;
@@ -556,7 +586,11 @@ type GetRenderedItemResult<ItemT> = {
 };
 type GetRenderedItem = (key: string) => GetRenderedItemResult<any> | null;
 
-declare const LegendList: <T>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
+interface LazyLegendListProps<ItemT, ListT> extends Omit<LegendListProps<ItemT>, "data" | "keyExtractor" | "renderItem"> {
+    children?: React$1.ReactNode | undefined;
+    LegendList?: ListT;
+}
+declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
     alignItemsAtEnd?: boolean;
     columnWrapperStyle?: ColumnWrapperStyle;
     data: readonly T[];
@@ -567,7 +601,7 @@ declare const LegendList: <T>(props: Omit<Omit<react_native.ScrollViewProps, "sc
         width: number;
     };
     extraData?: any;
-    getEstimatedItemSize?: ((index: number, item: T) => number) | undefined;
+    getEstimatedItemSize?: ((index: number, item: T, type: string | undefined) => number) | undefined;
     initialContainerPoolRatio?: number | undefined;
     initialScrollOffset?: number;
     initialScrollIndex?: number | {
@@ -607,9 +641,9 @@ declare const LegendList: <T>(props: Omit<Omit<react_native.ScrollViewProps, "sc
     onViewableItemsChanged?: OnViewableItemsChanged | undefined;
     progressViewOffset?: number;
     recycleItems?: boolean;
-    refScrollView?: React$1.Ref<ScrollView>;
+    refScrollView?: React$1.Ref<react_native.ScrollView>;
     refreshing?: boolean;
-    renderItem?: React$1.ComponentType<LegendListRenderItemProps<T>> | ((props: LegendListRenderItemProps<T>) => React$1.ReactNode) | undefined;
+    renderItem?: ((props: LegendListRenderItemProps<T, string | undefined>) => React$1.ReactNode) | React$1.ComponentType<LegendListRenderItemProps<T, string | undefined>> | undefined;
     renderScrollComponent?: (props: react_native.ScrollViewProps) => React$1.ReactElement<react_native.ScrollViewProps>;
     suggestEstimatedItemSize?: boolean;
     viewabilityConfig?: ViewabilityConfig;
@@ -618,13 +652,12 @@ declare const LegendList: <T>(props: Omit<Omit<react_native.ScrollViewProps, "sc
     onLoad?: (info: {
         elapsedTimeInMs: number;
     }) => void;
-} & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode;
-
-interface LazyLegendListProps<ItemT, ListT> extends Omit<LegendListProps<ItemT>, "data" | "keyExtractor" | "renderItem"> {
-    children?: React$1.ReactNode | undefined;
-    LegendList?: ListT;
-}
-declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
+    snapToIndices?: number[];
+    stickyIndices?: number[];
+    getItemType?: ((item: T, index: number) => string | undefined) | undefined;
+    getFixedItemSize?: ((index: number, item: T, type: string | undefined) => number) | undefined;
+    itemsAreEqual?: ((itemPrevious: T, item: T, index: number, data: readonly T[]) => boolean) | undefined;
+} & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode) | react_native.Animated.AnimatedComponent<(<T>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
     alignItemsAtEnd?: boolean;
     columnWrapperStyle?: ColumnWrapperStyle;
     data: readonly T[];
@@ -635,7 +668,7 @@ declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_
         width: number;
     };
     extraData?: any;
-    getEstimatedItemSize?: ((index: number, item: T) => number) | undefined;
+    getEstimatedItemSize?: ((index: number, item: T, type: string | undefined) => number) | undefined;
     initialContainerPoolRatio?: number | undefined;
     initialScrollOffset?: number;
     initialScrollIndex?: number | {
@@ -677,7 +710,7 @@ declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_
     recycleItems?: boolean;
     refScrollView?: React$1.Ref<react_native.ScrollView>;
     refreshing?: boolean;
-    renderItem?: React$1.ComponentType<LegendListRenderItemProps<T>> | ((props: LegendListRenderItemProps<T>) => React$1.ReactNode) | undefined;
+    renderItem?: ((props: LegendListRenderItemProps<T, string | undefined>) => React$1.ReactNode) | React$1.ComponentType<LegendListRenderItemProps<T, string | undefined>> | undefined;
     renderScrollComponent?: (props: react_native.ScrollViewProps) => React$1.ReactElement<react_native.ScrollViewProps>;
     suggestEstimatedItemSize?: boolean;
     viewabilityConfig?: ViewabilityConfig;
@@ -686,7 +719,14 @@ declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_
     onLoad?: (info: {
         elapsedTimeInMs: number;
     }) => void;
-} & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode) | react_native.Animated.AnimatedComponent<(<T>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
+    snapToIndices?: number[];
+    stickyIndices?: number[];
+    getItemType?: ((item: T, index: number) => string | undefined) | undefined;
+    getFixedItemSize?: ((index: number, item: T, type: string | undefined) => number) | undefined;
+    itemsAreEqual?: ((itemPrevious: T, item: T, index: number, data: readonly T[]) => boolean) | undefined;
+} & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode)> | (<ItemT_1>(props: _legendapp_list_reanimated.AnimatedLegendListProps<ItemT_1> & {
+    ref?: React$1.Ref<LegendListRef>;
+}) => React$1.ReactElement | null) = <T>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
     alignItemsAtEnd?: boolean;
     columnWrapperStyle?: ColumnWrapperStyle;
     data: readonly T[];
@@ -697,7 +737,7 @@ declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_
         width: number;
     };
     extraData?: any;
-    getEstimatedItemSize?: ((index: number, item: T) => number) | undefined;
+    getEstimatedItemSize?: ((index: number, item: T, type: string | undefined) => number) | undefined;
     initialContainerPoolRatio?: number | undefined;
     initialScrollOffset?: number;
     initialScrollIndex?: number | {
@@ -739,7 +779,7 @@ declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_
     recycleItems?: boolean;
     refScrollView?: React$1.Ref<react_native.ScrollView>;
     refreshing?: boolean;
-    renderItem?: React$1.ComponentType<LegendListRenderItemProps<T>> | ((props: LegendListRenderItemProps<T>) => React$1.ReactNode) | undefined;
+    renderItem?: ((props: LegendListRenderItemProps<T, string | undefined>) => React$1.ReactNode) | React$1.ComponentType<LegendListRenderItemProps<T, string | undefined>> | undefined;
     renderScrollComponent?: (props: react_native.ScrollViewProps) => React$1.ReactElement<react_native.ScrollViewProps>;
     suggestEstimatedItemSize?: boolean;
     viewabilityConfig?: ViewabilityConfig;
@@ -748,9 +788,14 @@ declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_
     onLoad?: (info: {
         elapsedTimeInMs: number;
     }) => void;
-} & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode)> | (<ItemT_1>(props: _legendapp_list_reanimated.AnimatedLegendListProps<ItemT_1> & {
-    ref?: React$1.Ref<LegendListRef>;
-}) => React$1.ReactElement | null) = <T>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
+    snapToIndices?: number[];
+    stickyIndices?: number[];
+    getItemType?: ((item: T, index: number) => string | undefined) | undefined;
+    getFixedItemSize?: ((index: number, item: T, type: string | undefined) => number) | undefined;
+    itemsAreEqual?: ((itemPrevious: T, item: T, index: number, data: readonly T[]) => boolean) | undefined;
+} & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode>(props: LazyLegendListProps<ItemT, ListT> & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode;
+
+declare const LegendList: <T>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
     alignItemsAtEnd?: boolean;
     columnWrapperStyle?: ColumnWrapperStyle;
     data: readonly T[];
@@ -761,7 +806,7 @@ declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_
         width: number;
     };
     extraData?: any;
-    getEstimatedItemSize?: ((index: number, item: T) => number) | undefined;
+    getEstimatedItemSize?: ((index: number, item: T, type: string | undefined) => number) | undefined;
     initialContainerPoolRatio?: number | undefined;
     initialScrollOffset?: number;
     initialScrollIndex?: number | {
@@ -801,9 +846,9 @@ declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_
     onViewableItemsChanged?: OnViewableItemsChanged | undefined;
     progressViewOffset?: number;
     recycleItems?: boolean;
-    refScrollView?: React$1.Ref<react_native.ScrollView>;
+    refScrollView?: React$1.Ref<ScrollView>;
     refreshing?: boolean;
-    renderItem?: React$1.ComponentType<LegendListRenderItemProps<T>> | ((props: LegendListRenderItemProps<T>) => React$1.ReactNode) | undefined;
+    renderItem?: ((props: LegendListRenderItemProps<T, string | undefined>) => React$1.ReactNode) | React$1.ComponentType<LegendListRenderItemProps<T, string | undefined>> | undefined;
     renderScrollComponent?: (props: react_native.ScrollViewProps) => React$1.ReactElement<react_native.ScrollViewProps>;
     suggestEstimatedItemSize?: boolean;
     viewabilityConfig?: ViewabilityConfig;
@@ -812,7 +857,12 @@ declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_
     onLoad?: (info: {
         elapsedTimeInMs: number;
     }) => void;
-} & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode>(props: LazyLegendListProps<ItemT, ListT> & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode;
+    snapToIndices?: number[];
+    stickyIndices?: number[];
+    getItemType?: ((item: T, index: number) => string | undefined) | undefined;
+    getFixedItemSize?: ((index: number, item: T, type: string | undefined) => number) | undefined;
+    itemsAreEqual?: ((itemPrevious: T, item: T, index: number, data: readonly T[]) => boolean) | undefined;
+} & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode;
 
 declare function useViewability(callback: ViewabilityCallback, configId?: string): void;
 declare function useViewabilityAmount(callback: ViewabilityAmountCallback): void;