@legendapp/list 2.0.0-next.1 → 2.0.0-next.11

package/animated.d.mts

@@ -14,7 +14,7 @@ declare const AnimatedLegendList: Animated.AnimatedComponent<(<T>(props: Omit<Om
         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 | {
@@ -31,7 +31,7 @@ declare const AnimatedLegendList: Animated.AnimatedComponent<(<T>(props: Omit<Om
     ListFooterComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
     ListHeaderComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
     ListHeaderComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
-    maintainScrollAtEnd?: boolean;
+    maintainScrollAtEnd?: boolean | _legendapp_list.MaintainScrollAtEndOptions;
     maintainScrollAtEndThreshold?: number;
     maintainVisibleContentPosition?: boolean;
     numColumns?: number;
@@ -56,7 +56,7 @@ declare const AnimatedLegendList: Animated.AnimatedComponent<(<T>(props: Omit<Om
     recycleItems?: boolean;
     refScrollView?: React.Ref<react_native.ScrollView>;
     refreshing?: boolean;
-    renderItem?: React$1.ComponentType<_legendapp_list.LegendListRenderItemProps<T>> | ((props: _legendapp_list.LegendListRenderItemProps<T>) => React$1.ReactNode) | undefined;
+    renderItem?: ((props: _legendapp_list.LegendListRenderItemProps<T, string | undefined>) => React$1.ReactNode) | React$1.ComponentType<_legendapp_list.LegendListRenderItemProps<T, string | undefined>> | undefined;
     renderScrollComponent?: (props: react_native.ScrollViewProps) => React.ReactElement<react_native.ScrollViewProps>;
     suggestEstimatedItemSize?: boolean;
     viewabilityConfig?: _legendapp_list.ViewabilityConfig;
@@ -65,6 +65,10 @@ declare const AnimatedLegendList: Animated.AnimatedComponent<(<T>(props: Omit<Om
     onLoad?: (info: {
         elapsedTimeInMs: number;
     }) => void;
+    snapToIndices?: number[];
+    stickyIndices?: number[];
+    getItemType?: ((item: T, index: number) => string | undefined) | undefined;
+    getFixedItemSize?: ((index: number, item: T, type: string | undefined) => number) | undefined;
 } & React$1.RefAttributes<_legendapp_list.LegendListRef>) => React.ReactNode)>;
 
 export { AnimatedLegendList };

package/animated.d.ts

@@ -14,7 +14,7 @@ declare const AnimatedLegendList: Animated.AnimatedComponent<(<T>(props: Omit<Om
         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 | {
@@ -31,7 +31,7 @@ declare const AnimatedLegendList: Animated.AnimatedComponent<(<T>(props: Omit<Om
     ListFooterComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
     ListHeaderComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
     ListHeaderComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
-    maintainScrollAtEnd?: boolean;
+    maintainScrollAtEnd?: boolean | _legendapp_list.MaintainScrollAtEndOptions;
     maintainScrollAtEndThreshold?: number;
     maintainVisibleContentPosition?: boolean;
     numColumns?: number;
@@ -56,7 +56,7 @@ declare const AnimatedLegendList: Animated.AnimatedComponent<(<T>(props: Omit<Om
     recycleItems?: boolean;
     refScrollView?: React.Ref<react_native.ScrollView>;
     refreshing?: boolean;
-    renderItem?: React$1.ComponentType<_legendapp_list.LegendListRenderItemProps<T>> | ((props: _legendapp_list.LegendListRenderItemProps<T>) => React$1.ReactNode) | undefined;
+    renderItem?: ((props: _legendapp_list.LegendListRenderItemProps<T, string | undefined>) => React$1.ReactNode) | React$1.ComponentType<_legendapp_list.LegendListRenderItemProps<T, string | undefined>> | undefined;
     renderScrollComponent?: (props: react_native.ScrollViewProps) => React.ReactElement<react_native.ScrollViewProps>;
     suggestEstimatedItemSize?: boolean;
     viewabilityConfig?: _legendapp_list.ViewabilityConfig;
@@ -65,6 +65,10 @@ declare const AnimatedLegendList: Animated.AnimatedComponent<(<T>(props: Omit<Om
     onLoad?: (info: {
         elapsedTimeInMs: number;
     }) => void;
+    snapToIndices?: number[];
+    stickyIndices?: number[];
+    getItemType?: ((item: T, index: number) => string | undefined) | undefined;
+    getFixedItemSize?: ((index: number, item: T, type: string | undefined) => number) | undefined;
 } & React$1.RefAttributes<_legendapp_list.LegendListRef>) => React.ReactNode)>;
 
 export { AnimatedLegendList };

package/animated.js

@@ -1,9 +1,9 @@
 'use strict';
 
-var list = require('@legendapp/list');
 var reactNative = require('react-native');
+var list = require('@legendapp/list');
 
-// src/animated.tsx
+// src/integrations/animated.tsx
 var AnimatedLegendList = reactNative.Animated.createAnimatedComponent(list.LegendList);
 
 exports.AnimatedLegendList = AnimatedLegendList;

package/animated.mjs

@@ -1,7 +1,7 @@
-import { LegendList } from '@legendapp/list';
 import { Animated } from 'react-native';
+import { LegendList } from '@legendapp/list';
 
-// src/animated.tsx
+// src/integrations/animated.tsx
 var AnimatedLegendList = Animated.createAnimatedComponent(LegendList);
 
 export { AnimatedLegendList };

package/index.d.mts

@@ -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, StyleProp, ViewStyle, ScrollViewProps, NativeSyntheticEvent, NativeScrollEvent, ScrollViewComponent, ScrollResponderMixin } from 'react-native';
-import Animated from 'react-native-reanimated';
-import * as _legendapp_list_reanimated from '@legendapp/list/reanimated';
+import { View, Animated, ScrollView, StyleProp, ViewStyle, ScrollViewProps, LayoutRectangle, ScrollViewComponent, ScrollResponderMixin } 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" | "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>> = 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
@@ -122,7 +123,7 @@ type LegendListPropsBase<ItemT, TScrollView extends ComponentProps<typeof Scroll
      * If true, auto-scrolls to end when new items are added.
      * @default false
      */
-    maintainScrollAtEnd?: boolean;
+    maintainScrollAtEnd?: boolean | MaintainScrollAtEndOptions;
     /**
      * Distance threshold in percentage of screen size to trigger maintainScrollAtEnd.
      * @default 0.1
@@ -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,19 +233,35 @@ 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;
 };
+interface MaintainScrollAtEndOptions {
+    onLayout?: boolean;
+    onItemLayout?: boolean;
+    onDataChange?: boolean;
+}
 interface ColumnWrapperStyle {
     rowGap?: number;
     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;
@@ -309,48 +326,54 @@ interface InternalState {
     refScroller: React.RefObject<ScrollView>;
     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>;
     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;
-        maintainScrollAtEnd: boolean;
+        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[];
     };
 }
 interface ViewableRange<T> {
@@ -360,8 +383,9 @@ 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;
 }
@@ -371,6 +395,7 @@ type ScrollState = {
     endBuffered: number;
     isAtEnd: boolean;
     isAtStart: boolean;
+    positions: Map<string, number>;
     scroll: number;
     scrollLength: number;
     start: number;
@@ -423,9 +448,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.
@@ -534,7 +561,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;
@@ -550,7 +577,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[];
@@ -561,7 +592,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 | {
@@ -578,7 +609,7 @@ declare const LegendList: <T>(props: Omit<Omit<react_native.ScrollViewProps, "sc
     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;
+    maintainScrollAtEnd?: boolean | MaintainScrollAtEndOptions;
     maintainScrollAtEndThreshold?: number;
     maintainVisibleContentPosition?: boolean;
     numColumns?: number;
@@ -601,9 +632,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;
@@ -612,13 +643,11 @@ 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;
+} & 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[];
@@ -629,7 +658,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 | {
@@ -646,7 +675,7 @@ declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_
     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;
+    maintainScrollAtEnd?: boolean | MaintainScrollAtEndOptions;
     maintainScrollAtEndThreshold?: number;
     maintainVisibleContentPosition?: boolean;
     numColumns?: number;
@@ -671,7 +700,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;
@@ -680,7 +709,13 @@ 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;
+} & 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[];
@@ -691,7 +726,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 | {
@@ -708,7 +743,7 @@ declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_
     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;
+    maintainScrollAtEnd?: boolean | MaintainScrollAtEndOptions;
     maintainScrollAtEndThreshold?: number;
     maintainVisibleContentPosition?: boolean;
     numColumns?: number;
@@ -733,7 +768,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;
@@ -742,9 +777,13 @@ 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;
+} & 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[];
@@ -755,7 +794,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 | {
@@ -772,7 +811,7 @@ declare const LazyLegendList: <ItemT, ListT extends (<T>(props: Omit<Omit<react_
     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;
+    maintainScrollAtEnd?: boolean | MaintainScrollAtEndOptions;
     maintainScrollAtEndThreshold?: number;
     maintainVisibleContentPosition?: boolean;
     numColumns?: number;
@@ -795,9 +834,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;
@@ -806,7 +845,11 @@ 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;
+} & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode;
 
 declare function useViewability(callback: ViewabilityCallback, configId?: string): void;
 declare function useViewabilityAmount(callback: ViewabilityAmountCallback): void;
@@ -818,4 +861,4 @@ declare function useListScrollSize(): {
     height: number;
 };
 
-export { type ColumnWrapperStyle, type GetRenderedItem, type GetRenderedItemResult, type InternalState, LazyLegendList, type LazyLegendListProps, LegendList, type LegendListProps, type LegendListPropsBase, type LegendListRecyclingState, type LegendListRef, type LegendListRenderItemProps, 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, 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 };