@legendapp/list 2.0.0-next.9 → 2.0.1

package/index.d.ts

@@ -1,11 +1,9 @@
-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, LayoutRectangle, ScrollViewComponent, ScrollResponderMixin, StyleProp, ViewStyle, NativeSyntheticEvent, NativeScrollEvent, ScrollViewProps } from 'react-native';
 import Animated$1 from 'react-native-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" | "snapToOffsets" | "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>;
@@ -13,8 +11,16 @@ interface StateContext {
     mapViewabilityValues: Map<string, ViewToken>;
     mapViewabilityAmountCallbacks: Map<number, ViewabilityAmountCallback>;
     mapViewabilityAmountValues: Map<number, ViewAmountToken>;
+    mapViewabilityConfigStates: Map<string, {
+        viewableItems: ViewToken[];
+        start: number;
+        end: number;
+        previousStart: number;
+        previousEnd: number;
+    }>;
     columnWrapperStyle: ColumnWrapperStyle | undefined;
     viewRefs: Map<number, React$1.RefObject<View>>;
+    animatedScrollY: Animated.Value;
 }
 
 declare class ScrollAdjustHandler {
@@ -24,23 +30,51 @@ declare class ScrollAdjustHandler {
     constructor(ctx: StateContext);
     requestAdjust(add: number): void;
     setMounted(): void;
+    getAdjust(): number;
 }
 
-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 BaseScrollViewProps<TScrollView> = Omit<TScrollView, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children" | "onScroll">;
+interface DataModeProps<ItemT, TItemType extends string | undefined> {
+    /**
+     * Array of items to render in the list.
+     * @required when using data mode
+     */
+    data: ReadonlyArray<ItemT>;
+    /**
+     * Function or React component to render each item in the list.
+     * Can be either:
+     * - A function: (props: LegendListRenderItemProps<ItemT>) => ReactNode
+     * - A React component: React.ComponentType<LegendListRenderItemProps<ItemT>>
+     * @required when using data mode
+     */
+    renderItem: ((props: LegendListRenderItemProps<ItemT, TItemType>) => ReactNode) | React.ComponentType<LegendListRenderItemProps<ItemT, TItemType>>;
+    children?: never;
+}
+interface ChildrenModeProps {
+    /**
+     * React children elements to render as list items.
+     * Each child will be treated as an individual list item.
+     * @required when using children mode
+     */
+    children: ReactNode;
+    data?: never;
+    renderItem?: never;
+}
+interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
     /**
      * If true, aligns items at the end of the list.
      * @default false
      */
     alignItemsAtEnd?: boolean;
     /**
-     * Style applied to each column's wrapper view.
+     * If true, enables using average sizes for performance optimization.
+     * @default true
      */
-    columnWrapperStyle?: ColumnWrapperStyle;
+    enableAverages?: boolean;
     /**
-     * Array of items to render in the list.
-     * @required
+     * Style applied to each column's wrapper view.
      */
-    data: ReadonlyArray<ItemT>;
+    columnWrapperStyle?: ColumnWrapperStyle;
     /**
      * Distance in pixels to pre-render items ahead of the visible area.
      * @default 250
@@ -68,7 +102,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
@@ -86,7 +120,6 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
     initialScrollIndex?: number | {
         index: number;
         viewOffset?: number | undefined;
-        viewPosition?: number | undefined;
     };
     /**
      * Component to render between items, receiving the leading item as prop.
@@ -163,6 +196,7 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
      * Function to call when the user pulls to refresh.
      */
     onRefresh?: () => void;
+    onScroll?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
     /**
      * Called when scrolling reaches the start within onStartReachedThreshold.
      */
@@ -177,7 +211,7 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
     /**
      * Called when the viewability of items changes.
      */
-    onViewableItemsChanged?: OnViewableItemsChanged | undefined;
+    onViewableItemsChanged?: OnViewableItemsChanged<ItemT> | undefined;
     /**
      * Offset in pixels for the refresh indicator.
      * @default 0
@@ -197,14 +231,6 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
      * @default false
      */
     refreshing?: boolean;
-    /**
-     * Function or React component to render each item in the list.
-     * Can be either:
-     * - A function: (props: LegendListRenderItemProps<ItemT>) => ReactNode
-     * - A React component: React.ComponentType<LegendListRenderItemProps<ItemT>>
-     * @required
-     */
-    renderItem?: ((props: LegendListRenderItemProps<ItemT>) => ReactNode) | React.ComponentType<LegendListRenderItemProps<ItemT>>;
     /**
      * Render custom ScrollView component.
      * @default (props) => <ScrollView {...props} />
@@ -223,7 +249,7 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
     /**
      * Pairs of viewability configs and their callbacks for tracking visibility.
      */
-    viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs | undefined;
+    viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs<ItemT> | undefined;
     /**
      * If true, delays rendering until initial layout is complete.
      * @default false
@@ -233,7 +259,18 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
         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;
+}
+type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof ScrollView> | ComponentProps<typeof Animated.ScrollView> | ComponentProps<typeof Animated$1.ScrollView>, TItemType extends string | undefined = string | undefined> = BaseScrollViewProps<TScrollView> & LegendListSpecificProps<ItemT, TItemType> & (DataModeProps<ItemT, TItemType> | ChildrenModeProps);
 interface MaintainScrollAtEndOptions {
     onLayout?: boolean;
     onItemLayout?: boolean;
@@ -244,14 +281,14 @@ interface ColumnWrapperStyle {
     gap?: number;
     columnGap?: number;
 }
-type LegendListProps<ItemT> = LegendListPropsBase<ItemT, Omit<ComponentProps<typeof ScrollView>, "scrollEventThrottle">>;
+type LegendListProps<ItemT = any> = LegendListPropsBase<ItemT, ComponentProps<typeof ScrollView>>;
 interface InternalState {
     positions: Map<string, number>;
     columns: Map<string, number>;
     sizes: Map<string, number>;
     sizesKnown: Map<string, number>;
     containerItemKeys: Set<string>;
-    pendingAdjust: number;
+    containerItemTypes: Map<number, string>;
     isStartReached: boolean;
     isEndReached: boolean;
     isAtEnd: boolean;
@@ -279,7 +316,7 @@ interface InternalState {
     nativeMarginTop: number;
     indexByKey: Map<string, number>;
     idCache: Map<number, string>;
-    viewabilityConfigCallbackPairs: ViewabilityConfigCallbackPairs | undefined;
+    viewabilityConfigCallbackPairs: ViewabilityConfigCallbackPairs<any> | undefined;
     scrollHistory: Array<{
         scroll: number;
         time: number;
@@ -308,65 +345,57 @@ interface InternalState {
         animated?: boolean;
     } | undefined;
     needsOtherAxisSize?: boolean;
+    positionRange: {
+        start: number;
+        end: number;
+        valid: boolean;
+    };
     averageSizes: Record<string, {
         num: number;
         avg: number;
     }>;
     refScroller: React.RefObject<ScrollView>;
     loadStartTime: number;
-    initialScroll: ScrollIndexWithOffsetPosition | undefined;
+    initialScroll: ScrollIndexWithOffset | 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>>;
-        initialScroll: {
-            index: number;
-            viewOffset?: number;
-            viewPosition?: number;
-        } | undefined;
+        renderItem: LegendListProps["renderItem"];
+        initialScroll: ScrollIndexWithOffset | undefined;
         scrollBuffer: number;
         numColumns: number;
         initialContainerPoolRatio: number;
         stylePaddingTop: number | undefined;
         snapToIndices: number[] | undefined;
+        stickyIndicesSet: Set<number>;
+        stickyIndicesArr: number[];
+        itemsAreEqual: LegendListProps["itemsAreEqual"];
+        enableAverages: boolean;
     };
 }
 interface ViewableRange<T> {
@@ -376,24 +405,28 @@ 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;
+    data: readonly ItemT[];
     extraData: any;
 }
 type ScrollState = {
     contentLength: number;
+    data: readonly any[];
     end: number;
     endBuffered: number;
     isAtEnd: boolean;
     isAtStart: boolean;
+    positionAtIndex: (index: number) => number | undefined;
     positions: Map<string, number>;
     scroll: number;
     scrollLength: number;
+    sizeAtIndex: (index: number) => number | undefined;
+    sizes: Map<string, number>;
     start: number;
     startBuffered: number;
-    sizes: Map<string, number>;
-    sizeAtIndex: (index: number) => number;
 };
 type LegendListRef = {
     /**
@@ -440,9 +473,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.
@@ -488,6 +523,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;
@@ -503,14 +543,14 @@ interface ViewAmountToken<ItemT = any> extends ViewToken<ItemT> {
     percentOfScroller: number;
     scrollSize: number;
 }
-interface ViewabilityConfigCallbackPair {
+interface ViewabilityConfigCallbackPair<ItemT> {
     viewabilityConfig: ViewabilityConfig;
-    onViewableItemsChanged?: OnViewableItemsChanged;
+    onViewableItemsChanged?: OnViewableItemsChanged<ItemT>;
 }
-type ViewabilityConfigCallbackPairs = ViewabilityConfigCallbackPair[];
-type OnViewableItemsChanged = ((info: {
-    viewableItems: Array<ViewToken>;
-    changed: Array<ViewToken>;
+type ViewabilityConfigCallbackPairs<ItemT> = ViewabilityConfigCallbackPair<ItemT>[];
+type OnViewableItemsChanged<ItemT> = ((info: {
+    viewableItems: Array<ViewToken<ItemT>>;
+    changed: Array<ViewToken<ItemT>>;
 }) => void) | null;
 interface ViewabilityConfig {
     /**
@@ -541,8 +581,8 @@ interface ViewabilityConfig {
      */
     waitForInteraction?: boolean | undefined;
 }
-type ViewabilityCallback = (viewToken: ViewToken) => void;
-type ViewabilityAmountCallback = (viewToken: ViewAmountToken) => void;
+type ViewabilityCallback<ItemT = any> = (viewToken: ViewToken<ItemT>) => void;
+type ViewabilityAmountCallback<ItemT = any> = (viewToken: ViewAmountToken<ItemT>) => void;
 interface LegendListRecyclingState<T> {
     item: T;
     prevItem: T | undefined;
@@ -555,11 +595,13 @@ type TypedMemo = <T extends React.ComponentType<any>>(Component: T, propsAreEqua
     displayName?: string;
 };
 declare const typedMemo: TypedMemo;
-type ScrollIndexWithOffsetPosition = {
+interface ScrollIndexWithOffset {
     index: number;
-    viewOffset?: number;
-    viewPosition?: number;
-};
+    viewOffset: number;
+}
+interface ScrollIndexWithOffsetPosition extends ScrollIndexWithOffset {
+    viewPosition: number;
+}
 type GetRenderedItemResult<ItemT> = {
     index: number;
     item: ItemT;
@@ -567,270 +609,12 @@ type GetRenderedItemResult<ItemT> = {
 };
 type GetRenderedItem = (key: string) => GetRenderedItemResult<any> | null;
 
-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[];
-    drawDistance?: number;
-    estimatedItemSize?: number;
-    estimatedListSize?: {
-        height: number;
-        width: number;
-    };
-    extraData?: any;
-    getEstimatedItemSize?: ((index: number, item: T) => number) | undefined;
-    initialContainerPoolRatio?: number | undefined;
-    initialScrollOffset?: number;
-    initialScrollIndex?: number | {
-        index: number;
-        viewOffset?: number | undefined;
-        viewPosition?: number | undefined;
-    };
-    ItemSeparatorComponent?: React$1.ComponentType<{
-        leadingItem: T;
-    }> | undefined;
-    keyExtractor?: ((item: T, index: number) => string) | undefined;
-    ListEmptyComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ListFooterComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ListFooterComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
-    ListHeaderComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ListHeaderComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
-    maintainScrollAtEnd?: boolean | MaintainScrollAtEndOptions;
-    maintainScrollAtEndThreshold?: number;
-    maintainVisibleContentPosition?: boolean;
-    numColumns?: number;
-    onEndReached?: ((info: {
-        distanceFromEnd: number;
-    }) => void) | null | undefined;
-    onEndReachedThreshold?: number | null | undefined;
-    onItemSizeChanged?: ((info: {
-        size: number;
-        previous: number;
-        index: number;
-        itemKey: string;
-        itemData: T;
-    }) => void) | undefined;
-    onRefresh?: () => void;
-    onStartReached?: ((info: {
-        distanceFromStart: number;
-    }) => void) | null | undefined;
-    onStartReachedThreshold?: number | null | undefined;
-    onViewableItemsChanged?: OnViewableItemsChanged | undefined;
-    progressViewOffset?: number;
-    recycleItems?: boolean;
-    refScrollView?: React$1.Ref<react_native.ScrollView>;
-    refreshing?: boolean;
-    renderItem?: ((props: LegendListRenderItemProps<T>) => React$1.ReactNode) | React$1.ComponentType<LegendListRenderItemProps<T>> | undefined;
-    renderScrollComponent?: (props: react_native.ScrollViewProps) => React$1.ReactElement<react_native.ScrollViewProps>;
-    suggestEstimatedItemSize?: boolean;
-    viewabilityConfig?: ViewabilityConfig;
-    viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs | undefined;
-    waitForInitialLayout?: boolean;
-    onLoad?: (info: {
-        elapsedTimeInMs: number;
-    }) => void;
-    snapToIndices?: number[];
-} & 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[];
-    drawDistance?: number;
-    estimatedItemSize?: number;
-    estimatedListSize?: {
-        height: number;
-        width: number;
-    };
-    extraData?: any;
-    getEstimatedItemSize?: ((index: number, item: T) => number) | undefined;
-    initialContainerPoolRatio?: number | undefined;
-    initialScrollOffset?: number;
-    initialScrollIndex?: number | {
-        index: number;
-        viewOffset?: number | undefined;
-        viewPosition?: number | undefined;
-    };
-    ItemSeparatorComponent?: React$1.ComponentType<{
-        leadingItem: T;
-    }> | undefined;
-    keyExtractor?: ((item: T, index: number) => string) | undefined;
-    ListEmptyComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ListFooterComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ListFooterComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
-    ListHeaderComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ListHeaderComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
-    maintainScrollAtEnd?: boolean | MaintainScrollAtEndOptions;
-    maintainScrollAtEndThreshold?: number;
-    maintainVisibleContentPosition?: boolean;
-    numColumns?: number;
-    onEndReached?: ((info: {
-        distanceFromEnd: number;
-    }) => void) | null | undefined;
-    onEndReachedThreshold?: number | null | undefined;
-    onItemSizeChanged?: ((info: {
-        size: number;
-        previous: number;
-        index: number;
-        itemKey: string;
-        itemData: T;
-    }) => void) | undefined;
-    onRefresh?: () => void;
-    onStartReached?: ((info: {
-        distanceFromStart: number;
-    }) => void) | null | undefined;
-    onStartReachedThreshold?: number | null | undefined;
-    onViewableItemsChanged?: OnViewableItemsChanged | undefined;
-    progressViewOffset?: number;
-    recycleItems?: boolean;
-    refScrollView?: React$1.Ref<react_native.ScrollView>;
-    refreshing?: boolean;
-    renderItem?: ((props: LegendListRenderItemProps<T>) => React$1.ReactNode) | React$1.ComponentType<LegendListRenderItemProps<T>> | undefined;
-    renderScrollComponent?: (props: react_native.ScrollViewProps) => React$1.ReactElement<react_native.ScrollViewProps>;
-    suggestEstimatedItemSize?: boolean;
-    viewabilityConfig?: ViewabilityConfig;
-    viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs | undefined;
-    waitForInitialLayout?: boolean;
-    onLoad?: (info: {
-        elapsedTimeInMs: number;
-    }) => void;
-    snapToIndices?: number[];
-} & 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[];
-    drawDistance?: number;
-    estimatedItemSize?: number;
-    estimatedListSize?: {
-        height: number;
-        width: number;
-    };
-    extraData?: any;
-    getEstimatedItemSize?: ((index: number, item: T) => number) | undefined;
-    initialContainerPoolRatio?: number | undefined;
-    initialScrollOffset?: number;
-    initialScrollIndex?: number | {
-        index: number;
-        viewOffset?: number | undefined;
-        viewPosition?: number | undefined;
-    };
-    ItemSeparatorComponent?: React$1.ComponentType<{
-        leadingItem: T;
-    }> | undefined;
-    keyExtractor?: ((item: T, index: number) => string) | undefined;
-    ListEmptyComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ListFooterComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ListFooterComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
-    ListHeaderComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ListHeaderComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
-    maintainScrollAtEnd?: boolean | MaintainScrollAtEndOptions;
-    maintainScrollAtEndThreshold?: number;
-    maintainVisibleContentPosition?: boolean;
-    numColumns?: number;
-    onEndReached?: ((info: {
-        distanceFromEnd: number;
-    }) => void) | null | undefined;
-    onEndReachedThreshold?: number | null | undefined;
-    onItemSizeChanged?: ((info: {
-        size: number;
-        previous: number;
-        index: number;
-        itemKey: string;
-        itemData: T;
-    }) => void) | undefined;
-    onRefresh?: () => void;
-    onStartReached?: ((info: {
-        distanceFromStart: number;
-    }) => void) | null | undefined;
-    onStartReachedThreshold?: number | null | undefined;
-    onViewableItemsChanged?: OnViewableItemsChanged | undefined;
-    progressViewOffset?: number;
-    recycleItems?: boolean;
-    refScrollView?: React$1.Ref<react_native.ScrollView>;
-    refreshing?: boolean;
-    renderItem?: ((props: LegendListRenderItemProps<T>) => React$1.ReactNode) | React$1.ComponentType<LegendListRenderItemProps<T>> | undefined;
-    renderScrollComponent?: (props: react_native.ScrollViewProps) => React$1.ReactElement<react_native.ScrollViewProps>;
-    suggestEstimatedItemSize?: boolean;
-    viewabilityConfig?: ViewabilityConfig;
-    viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs | undefined;
-    waitForInitialLayout?: boolean;
-    onLoad?: (info: {
-        elapsedTimeInMs: number;
-    }) => void;
-    snapToIndices?: number[];
-} & 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[];
-    drawDistance?: number;
-    estimatedItemSize?: number;
-    estimatedListSize?: {
-        height: number;
-        width: number;
-    };
-    extraData?: any;
-    getEstimatedItemSize?: ((index: number, item: T) => number) | undefined;
-    initialContainerPoolRatio?: number | undefined;
-    initialScrollOffset?: number;
-    initialScrollIndex?: number | {
-        index: number;
-        viewOffset?: number | undefined;
-        viewPosition?: number | undefined;
-    };
-    ItemSeparatorComponent?: React$1.ComponentType<{
-        leadingItem: T;
-    }> | undefined;
-    keyExtractor?: ((item: T, index: number) => string) | undefined;
-    ListEmptyComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ListFooterComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ListFooterComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
-    ListHeaderComponent?: React$1.ComponentType<any> | React$1.ReactElement | null | undefined;
-    ListHeaderComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
-    maintainScrollAtEnd?: boolean | MaintainScrollAtEndOptions;
-    maintainScrollAtEndThreshold?: number;
-    maintainVisibleContentPosition?: boolean;
-    numColumns?: number;
-    onEndReached?: ((info: {
-        distanceFromEnd: number;
-    }) => void) | null | undefined;
-    onEndReachedThreshold?: number | null | undefined;
-    onItemSizeChanged?: ((info: {
-        size: number;
-        previous: number;
-        index: number;
-        itemKey: string;
-        itemData: T;
-    }) => void) | undefined;
-    onRefresh?: () => void;
-    onStartReached?: ((info: {
-        distanceFromStart: number;
-    }) => void) | null | undefined;
-    onStartReachedThreshold?: number | null | undefined;
-    onViewableItemsChanged?: OnViewableItemsChanged | undefined;
-    progressViewOffset?: number;
-    recycleItems?: boolean;
-    refScrollView?: React$1.Ref<ScrollView>;
-    refreshing?: boolean;
-    renderItem?: ((props: LegendListRenderItemProps<T>) => React$1.ReactNode) | React$1.ComponentType<LegendListRenderItemProps<T>> | undefined;
-    renderScrollComponent?: (props: react_native.ScrollViewProps) => React$1.ReactElement<react_native.ScrollViewProps>;
-    suggestEstimatedItemSize?: boolean;
-    viewabilityConfig?: ViewabilityConfig;
-    viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs | undefined;
-    waitForInitialLayout?: boolean;
-    onLoad?: (info: {
-        elapsedTimeInMs: number;
-    }) => void;
-    snapToIndices?: number[];
-} & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode;
+declare const LegendList: (<T>(props: LegendListProps<T> & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode) & {
+    displayName?: string;
+};
 
-declare function useViewability(callback: ViewabilityCallback, configId?: string): void;
-declare function useViewabilityAmount(callback: ViewabilityAmountCallback): void;
+declare function useViewability<ItemT = any>(callback: ViewabilityCallback<ItemT>, configId?: string): void;
+declare function useViewabilityAmount<ItemT = any>(callback: ViewabilityAmountCallback<ItemT>): void;
 declare function useRecyclingEffect(effect: (info: LegendListRecyclingState<unknown>) => void | (() => void)): void;
 declare function useRecyclingState<ItemT>(valueOrFun: ((info: LegendListRecyclingState<ItemT>) => ItemT) | ItemT): readonly [ItemT | null, Dispatch<SetStateAction<ItemT>>];
 declare function useIsLastItem(): boolean;
@@ -838,5 +622,6 @@ declare function useListScrollSize(): {
     width: number;
     height: number;
 };
+declare function useSyncLayout(): () => void;
 
-export { type ColumnWrapperStyle, type GetRenderedItem, type GetRenderedItemResult, type InternalState, LazyLegendList, type LazyLegendListProps, LegendList, type LegendListProps, type LegendListPropsBase, type LegendListRecyclingState, type LegendListRef, type LegendListRenderItemProps, type MaintainScrollAtEndOptions, type OnViewableItemsChanged, type ScrollIndexWithOffsetPosition, type ScrollState, type TypedForwardRef, type TypedMemo, type ViewAmountToken, type ViewToken, type ViewabilityAmountCallback, type ViewabilityCallback, type ViewabilityConfig, type ViewabilityConfigCallbackPair, type ViewabilityConfigCallbackPairs, type ViewableRange, typedForwardRef, typedMemo, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useViewability, useViewabilityAmount };
+export { type ColumnWrapperStyle, type GetRenderedItem, type GetRenderedItemResult, type InternalState, LegendList, type LegendListProps, type LegendListPropsBase, type LegendListRecyclingState, type LegendListRef, type LegendListRenderItemProps, type MaintainScrollAtEndOptions, type OnViewableItemsChanged, type ScrollIndexWithOffset, type ScrollIndexWithOffsetPosition, type ScrollState, type TypedForwardRef, type TypedMemo, type ViewAmountToken, type ViewToken, type ViewabilityAmountCallback, type ViewabilityCallback, type ViewabilityConfig, type ViewabilityConfigCallbackPair, type ViewabilityConfigCallbackPairs, type ViewableRange, typedForwardRef, typedMemo, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };