@legendapp/list 3.0.0-beta.43 → 3.0.0-beta.45

package/react.d.ts

@@ -26,18 +26,28 @@ interface ScrollViewMethods {
     }): void;
 }
 
-type AnimatedValue = number;
+interface MaintainVisibleContentPositionNormalized<ItemT = any> {
+    data: boolean;
+    size: boolean;
+    shouldRestorePosition?: (item: ItemT, index: number, data: readonly ItemT[]) => boolean;
+}
 
-type ListenerType = "activeStickyIndex" | "debugComputedScroll" | "debugRawScroll" | "extraData" | "footerSize" | "headerSize" | "lastItemKeys" | "lastPositionUpdate" | "maintainVisibleContentPosition" | "numColumns" | "numContainers" | "numContainersPooled" | "otherAxisSize" | "readyToRender" | "scrollAdjust" | "scrollAdjustPending" | "scrollAdjustUserOffset" | "scrollSize" | "snapToOffsets" | "stylePaddingTop" | "totalSize" | `containerColumn${number}` | `containerSpan${number}` | `containerItemData${number}` | `containerItemKey${number}` | `containerPosition${number}` | `containerSticky${number}`;
-type LegendListListenerType = Extract<ListenerType, "activeStickyIndex" | "footerSize" | "headerSize" | "lastItemKeys" | "lastPositionUpdate" | "numContainers" | "numContainersPooled" | "otherAxisSize" | "readyToRender" | "snapToOffsets" | "totalSize">;
+type ListenerType = "activeStickyIndex" | "anchoredEndSpaceSize" | "debugComputedScroll" | "debugRawScroll" | "extraData" | "footerSize" | "headerSize" | "lastItemKeys" | "lastPositionUpdate" | "maintainVisibleContentPosition" | "numColumns" | "numContainers" | "numContainersPooled" | "otherAxisSize" | "readyToRender" | "scrollAdjust" | "scrollAdjustPending" | "scrollAdjustUserOffset" | "scrollSize" | "snapToOffsets" | "stylePaddingTop" | "totalSize" | "isAtEnd" | "isAtStart" | "isNearEnd" | "isNearStart" | "isWithinMaintainScrollAtEndThreshold" | `containerColumn${number}` | `containerSpan${number}` | `containerItemData${number}` | `containerItemKey${number}` | `containerPosition${number}` | `containerSticky${number}`;
+type LegendListListenerType = Extract<ListenerType, "activeStickyIndex" | "anchoredEndSpaceSize" | "footerSize" | "headerSize" | "isAtEnd" | "isAtStart" | "isNearEnd" | "isNearStart" | "isWithinMaintainScrollAtEndThreshold" | "lastItemKeys" | "lastPositionUpdate" | "numContainers" | "numContainersPooled" | "otherAxisSize" | "readyToRender" | "snapToOffsets" | "totalSize">;
 type ListenerTypeValueMap = {
     activeStickyIndex: number;
+    anchoredEndSpaceSize: number;
     animatedScrollY: any;
     debugComputedScroll: number;
     debugRawScroll: number;
     extraData: any;
     footerSize: number;
     headerSize: number;
+    isAtEnd: boolean;
+    isAtStart: boolean;
+    isNearEnd: boolean;
+    isNearStart: boolean;
+    isWithinMaintainScrollAtEndThreshold: boolean;
     lastItemKeys: string[];
     lastPositionUpdate: number;
     maintainVisibleContentPosition: MaintainVisibleContentPositionNormalized;
@@ -69,44 +79,6 @@ type ListenerTypeValueMap = {
 } & {
     [K in ListenerType as K extends `containerSticky${number}` ? K : never]: boolean;
 };
-interface StateContext {
-    animatedScrollY: AnimatedValue;
-    columnWrapperStyle: ColumnWrapperStyle | undefined;
-    contextNum: number;
-    listeners: Map<ListenerType, Set<(value: any) => void>>;
-    mapViewabilityCallbacks: Map<string, ViewabilityCallback>;
-    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;
-    }>;
-    positionListeners: Map<string, Set<(value: any) => void>>;
-    state: InternalState;
-    values: Map<ListenerType, any>;
-    viewRefs: Map<number, React.RefObject<LooseView | null>>;
-}
-
-declare class ScrollAdjustHandler {
-    private appliedAdjust;
-    private pendingAdjust;
-    private ctx;
-    constructor(ctx: StateContext);
-    requestAdjust(add: number): void;
-    getAdjust(): number;
-    commitPendingAdjust(scrollTarget: ScrollTarget): void;
-}
-
-type BaseSharedValue<T = number> = {
-    get: () => T;
-};
-type StylesAsSharedValue<Style> = {
-    [key in keyof Style]: Style[key] | BaseSharedValue<Style[key]>;
-};
 
 interface Insets {
     top: number;
@@ -141,29 +113,6 @@ interface NativeSyntheticEvent<T> {
 }
 type ViewStyle = Record<string, unknown>;
 type StyleProp<T> = T | T[] | null | undefined | false;
-interface ScrollEventTargetLike {
-    addEventListener(type: string, listener: (...args: any[]) => void): void;
-    removeEventListener(type: string, listener: (...args: any[]) => void): void;
-}
-interface ScrollableNodeLike {
-    scrollLeft?: number;
-    scrollTop?: number;
-}
-interface LegendListScrollerRef {
-    flashScrollIndicators(): void;
-    getCurrentScrollOffset?(): number;
-    getScrollEventTarget(): ScrollEventTargetLike | null;
-    getScrollableNode(): ScrollableNodeLike | null;
-    getScrollResponder(): unknown;
-    scrollTo(options: {
-        animated?: boolean;
-        x?: number;
-        y?: number;
-    }): void;
-    scrollToEnd(options?: {
-        animated?: boolean;
-    }): void;
-}
 type BaseScrollViewProps<TScrollView> = Omit<TScrollView, "contentOffset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children" | "onScroll">;
 interface DataModeProps<ItemT, TItemType extends string | undefined> {
     /**
@@ -206,6 +155,11 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Style applied to each column's wrapper view.
      */
     columnWrapperStyle?: ColumnWrapperStyle;
+    /**
+     * Version token that forces the list to treat data as updated even when the array reference is stable.
+     * Increment or change this when mutating the data array in place.
+     */
+    dataVersion?: Key;
     /**
      * Distance in pixels to pre-render items ahead of the visible area.
      * @default 250
@@ -229,33 +183,35 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Extra data to trigger re-rendering when changed.
      */
     extraData?: any;
-    /**
-     * Version token that forces the list to treat data as updated even when the array reference is stable.
-     * Increment or change this when mutating the data array in place.
-     */
-    dataVersion?: Key;
     /**
      * 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?: (item: ItemT, index: number, type: TItemType) => number;
     /**
-     * Customize layout for multi-column lists, such as allowing items to span multiple columns.
-     * Similar to FlashList's overrideItemLayout.
+     * In case items always have a fixed size, you can provide a function to return it.
      */
-    overrideItemLayout?: (layout: {
-        span?: number;
-    }, item: ItemT, index: number, maxColumns: number, extraData?: any) => void;
+    getFixedItemSize?: (item: ItemT, index: number, type: TItemType) => number | undefined;
+    /**
+     * Returns a stable item type used for pooling and size estimation.
+     */
+    getItemType?: (item: ItemT, index: number) => TItemType;
+    /**
+     * Component to render between items, receiving the leading item as prop.
+     */
+    ItemSeparatorComponent?: React.ComponentType<{
+        leadingItem: ItemT;
+    }>;
     /**
      * Ratio of initial container pool size to data length (e.g., 0.5 for half).
      * @default 2
      */
     initialContainerPoolRatio?: number | undefined;
     /**
-     * Initial scroll position in pixels.
-     * @default 0
+     * When true, the list initializes scrolled to the last item.
+     * Overrides `initialScrollIndex` and `initialScrollOffset` when data is available.
+     * @default false
      */
-    initialScrollOffset?: number;
+    initialScrollAtEnd?: boolean;
     /**
      * Index to scroll to initially.
      * @default 0
@@ -266,17 +222,14 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
         viewPosition?: number | undefined;
     };
     /**
-     * When true, the list initializes scrolled to the last item.
-     * Overrides `initialScrollIndex` and `initialScrollOffset` when data is available.
-     * @default false
+     * Initial scroll position in pixels.
+     * @default 0
      */
-    initialScrollAtEnd?: boolean;
+    initialScrollOffset?: number;
     /**
-     * Component to render between items, receiving the leading item as prop.
+     * Custom equality function to detect semantically unchanged items.
      */
-    ItemSeparatorComponent?: React.ComponentType<{
-        leadingItem: ItemT;
-    }>;
+    itemsAreEqual?: (itemPrevious: ItemT, item: ItemT, index: number, data: readonly ItemT[]) => boolean;
     /**
      * Function to extract a unique key for each item.
      */
@@ -322,10 +275,9 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      */
     maintainVisibleContentPosition?: boolean | MaintainVisibleContentPositionConfig<ItemT>;
     /**
-     * Web only: when true, listens to window/body scrolling instead of rendering a scrollable list container.
-     * @default false
+     * Keeps an item visually anchored to the start by adding trailing space when the content below it underflows.
      */
-    useWindowScroll?: boolean;
+    anchoredEndSpace?: AnchoredEndSpaceConfig$1;
     /**
      * Number of columns to render items in.
      * @default 1
@@ -352,6 +304,12 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
         itemKey: string;
         itemData: ItemT;
     }) => void;
+    /**
+     * Called after the initial render work completes.
+     */
+    onLoad?: (info: {
+        elapsedTimeInMs: number;
+    }) => void;
     /**
      * Called when list layout metrics change.
      */
@@ -360,6 +318,9 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Function to call when the user pulls to refresh.
      */
     onRefresh?: () => void;
+    /**
+     * Called when the list scrolls.
+     */
     onScroll?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
     /**
      * Called when scrolling reaches the start within onStartReachedThreshold.
@@ -383,6 +344,12 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Called when the viewability of items changes.
      */
     onViewableItemsChanged?: OnViewableItemsChanged<ItemT> | undefined;
+    /**
+     * Customize layout for multi-column lists, such as allowing items to span multiple columns.
+     */
+    overrideItemLayout?: (layout: {
+        span?: number;
+    }, item: ItemT, index: number, maxColumns: number, extraData?: any) => void;
     /**
      * Offset in pixels for the refresh indicator.
      * @default 0
@@ -408,6 +375,10 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * @default (props) => <ScrollView {...props} />
      */
     renderScrollComponent?: (props: any) => React.ReactElement | null;
+    /**
+     * Array of item indices to use as snap points.
+     */
+    snapToIndices?: number[];
     /**
      * This will log a suggested estimatedItemSize.
      * @required
@@ -422,15 +393,6 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Pairs of viewability configs and their callbacks for tracking visibility.
      */
     viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs<ItemT> | undefined;
-    /**
-     * If true, delays rendering until initial layout is complete.
-     * @default false
-     */
-    waitForInitialLayout?: boolean;
-    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 stickyHeaderIndices={[0]} will cause the first child to be fixed to the top of the scroll view.
@@ -447,21 +409,24 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * @default undefined
      */
     stickyHeaderConfig?: StickyHeaderConfig;
-    getItemType?: (item: ItemT, index: number) => TItemType;
-    getFixedItemSize?: (item: ItemT, index: number, type: TItemType) => number | undefined;
-    itemsAreEqual?: (itemPrevious: ItemT, item: ItemT, index: number, data: readonly ItemT[]) => boolean;
+    /**
+     * Web only: when true, listens to window/body scrolling instead of rendering a scrollable list container.
+     * @default false
+     */
+    useWindowScroll?: boolean;
 }
 type LegendListPropsBase<ItemT, TScrollViewProps = Record<string, any>, TItemType extends string | undefined = string | undefined> = BaseScrollViewProps<TScrollViewProps> & LegendListSpecificProps<ItemT, TItemType> & (DataModeProps<ItemT, TItemType> | ChildrenModeProps);
-type LegendListPropsInternal = LegendListSpecificProps<any, string | undefined> & DataModeProps<any, string | undefined>;
 interface MaintainVisibleContentPositionConfig<ItemT = any> {
     data?: boolean;
     size?: boolean;
     shouldRestorePosition?: (item: ItemT, index: number, data: readonly ItemT[]) => boolean;
 }
-interface MaintainVisibleContentPositionNormalized<ItemT = any> {
-    data: boolean;
-    size: boolean;
-    shouldRestorePosition?: (item: ItemT, index: number, data: readonly ItemT[]) => boolean;
+interface AnchoredEndSpaceConfig$1 {
+    anchorIndex: number;
+    anchorOffset?: number;
+    anchorMaxSize?: number;
+    includeInEndInset?: boolean;
+    onSizeChanged?: (size: number) => void;
 }
 interface StickyHeaderConfig {
     /**
@@ -508,197 +473,6 @@ interface LegendListMetrics {
     headerSize: number;
     footerSize: number;
 }
-interface ThresholdSnapshot {
-    scrollPosition: number;
-    contentSize?: number;
-    dataLength?: number;
-    atThreshold: boolean;
-}
-interface ScrollTarget {
-    animated?: boolean;
-    index?: number;
-    isInitialScroll?: boolean;
-    itemSize?: number;
-    offset: number;
-    precomputedWithViewOffset?: boolean;
-    targetOffset?: number;
-    viewOffset?: number;
-    viewPosition?: number;
-}
-interface InternalState {
-    activeStickyIndex: number | undefined;
-    adjustingFromInitialMount?: number;
-    animFrameCheckFinishedScroll?: any;
-    averageSizes: Record<string, {
-        num: number;
-        avg: number;
-    }>;
-    columns: Array<number | undefined>;
-    columnSpans: Array<number | undefined>;
-    containerItemKeys: Map<string, number>;
-    containerItemTypes: Map<number, string>;
-    dataChangeEpoch: number;
-    dataChangeNeedsScrollUpdate: boolean;
-    didColumnsChange?: boolean;
-    didDataChange?: boolean;
-    didFinishInitialScroll?: boolean;
-    didContainersLayout?: boolean;
-    enableScrollForNextCalculateItemsInView: boolean;
-    endBuffered: number;
-    endNoBuffer: number;
-    endReachedSnapshot: ThresholdSnapshot | undefined;
-    firstFullyOnScreenIndex: number;
-    hasScrolled?: boolean;
-    idCache: string[];
-    idsInView: string[];
-    ignoreScrollFromMVCP?: {
-        lt?: number;
-        gt?: number;
-    };
-    ignoreScrollFromMVCPIgnored?: boolean;
-    ignoreScrollFromMVCPTimeout?: any;
-    indexByKey: Map<string, number>;
-    initialAnchor?: InitialScrollAnchor;
-    initialNativeScrollWatchdog?: {
-        startScroll: number;
-        targetOffset: number;
-    };
-    initialScrollLastDidFinish: boolean;
-    initialScrollLastTarget: ScrollIndexWithOffsetAndContentOffset | undefined;
-    initialScrollLastTargetUsesOffset: boolean;
-    initialScrollPreviousDataLength: number;
-    initialScrollRetryLastLength: number | undefined;
-    initialScrollRetryWindowUntil: number;
-    initialScroll: ScrollIndexWithOffsetAndContentOffset | undefined;
-    initialScrollUsesOffset: boolean;
-    isAtEnd: boolean;
-    isAtStart: boolean;
-    isEndReached: boolean | null;
-    isFirst?: boolean;
-    isStartReached: boolean | null;
-    lastBatchingAction: number;
-    lastLayout: LayoutRectangle | undefined;
-    lastScrollAdjustForHistory?: number;
-    lastScrollDelta: number;
-    loadStartTime: number;
-    maintainingScrollAtEnd?: boolean;
-    minIndexSizeChanged: number | undefined;
-    mvcpAnchorLock?: {
-        id: string;
-        position: number;
-        quietPasses: number;
-        expiresAt: number;
-    };
-    contentInsetOverride?: Partial<Insets> | null;
-    nativeContentInset?: Insets;
-    nativeMarginTop: number;
-    needsOtherAxisSize?: boolean;
-    otherAxisSize?: number;
-    pendingNativeMVCPAdjust?: {
-        amount: number;
-        furthestProgressTowardAmount: number;
-        manualApplied: number;
-        startScroll: number;
-    };
-    pendingMaintainScrollAtEnd?: boolean;
-    pendingTotalSize?: number;
-    pendingScrollResolve?: (() => void) | undefined;
-    positions: Array<number | undefined>;
-    previousData?: readonly unknown[];
-    queuedCalculateItemsInView: number | undefined;
-    queuedMVCPRecalculate?: number;
-    queuedInitialLayout?: boolean | undefined;
-    refScroller: React.RefObject<LegendListScrollerRef | null>;
-    scroll: number;
-    scrollAdjustHandler: ScrollAdjustHandler;
-    scrollForNextCalculateItemsInView: {
-        top: number | null;
-        bottom: number | null;
-    } | undefined;
-    scrollHistory: Array<{
-        scroll: number;
-        time: number;
-    }>;
-    scrollingTo?: ScrollTarget | undefined;
-    scrollLastCalculate?: number;
-    scrollLength: number;
-    scrollPending: number;
-    scrollPrev: number;
-    scrollPrevTime: number;
-    scrollProcessingEnabled: boolean;
-    scrollTime: number;
-    sizes: Map<string, number>;
-    sizesKnown: Map<string, number>;
-    startBuffered: number;
-    startBufferedId?: string;
-    startNoBuffer: number;
-    startReachedSnapshotDataChangeEpoch: number | undefined;
-    startReachedSnapshot: ThresholdSnapshot | undefined;
-    stickyContainerPool: Set<number>;
-    stickyContainers: Map<number, number>;
-    timeouts: Set<number>;
-    timeoutSetPaddingTop?: any;
-    timeoutSizeMessage: any;
-    timeoutCheckFinishedScrollFallback?: any;
-    totalSize: number;
-    triggerCalculateItemsInView?: (params?: {
-        doMVCP?: boolean;
-        dataChanged?: boolean;
-        forceFullItemPositions?: boolean;
-    }) => void;
-    viewabilityConfigCallbackPairs: ViewabilityConfigCallbackPairs<any> | undefined;
-    props: {
-        alignItemsAtEnd: boolean;
-        animatedProps: StylesAsSharedValue<Record<string, any>>;
-        alwaysRender: AlwaysRenderConfig | undefined;
-        alwaysRenderIndicesArr: number[];
-        alwaysRenderIndicesSet: Set<number>;
-        contentInset: Insets | undefined;
-        data: readonly any[];
-        dataVersion: Key | undefined;
-        drawDistance: number;
-        estimatedItemSize: number | undefined;
-        getEstimatedItemSize: LegendListPropsInternal["getEstimatedItemSize"];
-        getFixedItemSize: LegendListPropsInternal["getFixedItemSize"];
-        getItemType: LegendListPropsInternal["getItemType"];
-        horizontal: boolean;
-        initialContainerPoolRatio: number;
-        itemsAreEqual: LegendListPropsInternal["itemsAreEqual"];
-        keyExtractor: LegendListPropsInternal["keyExtractor"];
-        maintainScrollAtEnd: MaintainScrollAtEndNormalized | undefined;
-        maintainScrollAtEndThreshold: number | undefined;
-        maintainVisibleContentPosition: MaintainVisibleContentPositionNormalized;
-        numColumns: number;
-        onEndReached: LegendListPropsInternal["onEndReached"];
-        onEndReachedThreshold: number | null | undefined;
-        onItemSizeChanged: LegendListPropsInternal["onItemSizeChanged"];
-        onLoad: LegendListPropsInternal["onLoad"];
-        onScroll: LegendListPropsInternal["onScroll"];
-        onStartReached: LegendListPropsInternal["onStartReached"];
-        onStartReachedThreshold: number | null | undefined;
-        onStickyHeaderChange: LegendListPropsInternal["onStickyHeaderChange"];
-        overrideItemLayout: LegendListPropsInternal["overrideItemLayout"];
-        recycleItems: boolean;
-        renderItem: LegendListPropsInternal["renderItem"];
-        scrollBuffer?: number;
-        snapToIndices: number[] | undefined;
-        positionComponentInternal: React.ComponentType<any> | undefined;
-        stickyPositionComponentInternal: React.ComponentType<any> | undefined;
-        stickyIndicesArr: number[];
-        stickyIndicesSet: Set<number>;
-        stylePaddingBottom: number | undefined;
-        stylePaddingTop: number | undefined;
-        suggestEstimatedItemSize: boolean;
-        useWindowScroll: boolean;
-    };
-}
-interface ViewableRange<T> {
-    end: number;
-    endBuffered: number;
-    items: T[];
-    start: number;
-    startBuffered: number;
-}
 interface LegendListRenderItemProps<ItemT, TItemType extends string | number | undefined = string | number | undefined> {
     data: readonly ItemT[];
     extraData: any;
@@ -715,8 +489,11 @@ type LegendListState$1 = {
     endBuffered: number;
     isAtEnd: boolean;
     isAtStart: boolean;
+    isNearEnd: boolean;
+    isNearStart: boolean;
     isEndReached: boolean;
     isStartReached: boolean;
+    isWithinMaintainScrollAtEndThreshold: boolean;
     listen: <T extends LegendListListenerType>(listenerType: T, callback: (value: ListenerTypeValueMap[T]) => void) => () => void;
     listenToPosition: (key: string, callback: (value: number) => void) => () => void;
     positionAtIndex: (index: number) => number;
@@ -862,10 +639,15 @@ interface ViewabilityConfigCallbackPair<ItemT = any> {
     viewabilityConfig: ViewabilityConfig;
 }
 type ViewabilityConfigCallbackPairs<ItemT> = ViewabilityConfigCallbackPair<ItemT>[];
-type OnViewableItemsChanged<ItemT> = ((info: {
-    viewableItems: Array<ViewToken<ItemT>>;
+interface OnViewableItemsChangedInfo<ItemT> {
     changed: Array<ViewToken<ItemT>>;
-}) => void) | null;
+    end: number;
+    endBuffered: number;
+    start: number;
+    startBuffered: number;
+    viewableItems: Array<ViewToken<ItemT>>;
+}
+type OnViewableItemsChanged<ItemT> = ((info: OnViewableItemsChangedInfo<ItemT>) => void) | null;
 interface ViewabilityConfig {
     /**
      * A unique ID to identify this viewability config
@@ -903,12 +685,6 @@ interface LegendListRecyclingState<T> {
     prevIndex: number | undefined;
     prevItem: T | undefined;
 }
-type TypedForwardRef = <T, P = {}>(render: (props: P, ref: React.Ref<T>) => React.ReactElement | null) => (props: P & React.RefAttributes<T>) => React.ReactElement | null;
-declare const typedForwardRef: TypedForwardRef;
-type TypedMemo = <T extends React.ComponentType<any>>(Component: T, propsAreEqual?: (prevProps: Readonly<React.ComponentProps<T>>, nextProps: Readonly<React.ComponentProps<T>>) => boolean) => T & {
-    displayName?: string;
-};
-declare const typedMemo: TypedMemo;
 interface ScrollIndexWithOffset {
     index: number;
     viewOffset?: number;
@@ -920,28 +696,20 @@ interface ScrollIndexWithOffsetPosition extends ScrollIndexWithOffset {
 interface ScrollIndexWithOffsetAndContentOffset extends ScrollIndexWithOffsetPosition {
     contentOffset?: number;
 }
+/** @deprecated Kept for backwards compatibility. Use `ScrollIndexWithOffsetPosition`. */
 interface InitialScrollAnchor extends ScrollIndexWithOffsetPosition {
     attempts?: number;
     lastDelta?: number;
     settledTicks?: number;
 }
-type GetRenderedItemResult<ItemT> = {
-    index: number;
-    item: ItemT;
-    renderedItem: React.ReactNode;
-};
-type GetRenderedItem = (key: string) => GetRenderedItemResult<any> | null;
 
 type LooseLayoutChangeEvent = {
     nativeEvent: {
         layout: LayoutRectangle;
     };
 };
-type LooseMeasureCallback = (x: number, y: number, width: number, height: number, pageX: number, pageY: number) => void;
-interface LooseView {
-    measure?: (callback: LooseMeasureCallback) => void;
-}
 interface LooseScrollViewProps {
+    contentContainerClassName?: string;
     contentContainerStyle?: StyleProp<ViewStyle>;
     contentInset?: Insets;
     contentOffset?: {
@@ -966,13 +734,17 @@ interface LooseScrollViewProps {
     style?: StyleProp<ViewStyle>;
 }
 
-type ScrollViewPropsWeb = Omit<LooseScrollViewProps, "style" | "contentContainerStyle" | "onScroll" | "onLayout" | "pagingEnabled" | "snapToInterval"> & Omit<HTMLAttributes<HTMLDivElement>, "onScroll" | "onLayout" | "style"> & {
+interface AnchoredEndSpaceConfig extends Omit<AnchoredEndSpaceConfig$1, "includeInEndInset"> {
+}
+type ScrollViewPropsWeb = Omit<LooseScrollViewProps, "style" | "contentContainerStyle" | "onScroll" | "onLayout" | "onMomentumScrollBegin" | "onMomentumScrollEnd" | "pagingEnabled" | "snapToInterval"> & Omit<HTMLAttributes<HTMLDivElement>, "onScroll" | "onLayout" | "style"> & {
     style?: CSSProperties;
+    contentContainerClassName?: string;
     contentContainerStyle?: CSSProperties;
     onScroll?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
     onLayout?: (event: LooseLayoutChangeEvent) => void;
 };
-type LegendListPropsOverrides<ItemT, TItemType extends string | undefined> = Omit<LegendListPropsBase<ItemT, ScrollViewPropsWeb, TItemType>, "refScrollView" | "renderScrollComponent" | "ListHeaderComponentStyle" | "ListFooterComponentStyle"> & {
+type LegendListPropsOverrides<ItemT, TItemType extends string | undefined> = Omit<LegendListPropsBase<ItemT, ScrollViewPropsWeb, TItemType>, "anchoredEndSpace" | "refScrollView" | "renderScrollComponent" | "ListHeaderComponentStyle" | "ListFooterComponentStyle" | "onRefresh" | "progressViewOffset" | "refreshing"> & {
+    anchoredEndSpace?: AnchoredEndSpaceConfig;
     refScrollView?: Ref<HTMLElement | ScrollViewMethods>;
     ListHeaderComponentStyle?: CSSProperties | undefined;
     ListFooterComponentStyle?: CSSProperties | undefined;
@@ -1001,4 +773,4 @@ declare function useSyncLayout(): () => void;
 
 declare const LegendList: LegendListComponent;
 
-export { type AlwaysRenderConfig, type BaseScrollViewProps, type ColumnWrapperStyle, type GetRenderedItem, type GetRenderedItemResult, type InitialScrollAnchor, type Insets, type InternalState, type LayoutRectangle, LegendList, type LegendListComponent, type LegendListMetrics, type LegendListProps, type LegendListPropsBase, type LegendListRecyclingState, type LegendListRef, type LegendListRenderItemProps, type LegendListScrollerRef, type LegendListState, type MaintainScrollAtEndOnOptions, type MaintainScrollAtEndOptions, type MaintainVisibleContentPositionConfig, type MaintainVisibleContentPositionNormalized, type NativeScrollEvent, type NativeSyntheticEvent, type OnViewableItemsChanged, type ScrollEventTargetLike, type ScrollIndexWithOffset, type ScrollIndexWithOffsetAndContentOffset, type ScrollIndexWithOffsetPosition, type ScrollTarget, type ScrollableNodeLike, type StickyHeaderConfig, type StyleProp, type ThresholdSnapshot, type TypedForwardRef, type TypedMemo, type ViewAmountToken, type ViewStyle, type ViewToken, type ViewabilityAmountCallback, type ViewabilityCallback, type ViewabilityConfig, type ViewabilityConfigCallbackPair, type ViewabilityConfigCallbackPairs, type ViewableRange, typedForwardRef, typedMemo, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };
+export { type AlwaysRenderConfig, type AnchoredEndSpaceConfig, type ColumnWrapperStyle, type InitialScrollAnchor, type Insets, type LayoutRectangle, LegendList, type LegendListComponent, type LegendListMetrics, type LegendListProps, type LegendListRecyclingState, type LegendListRef, type LegendListRenderItemProps, type LegendListState, type MaintainScrollAtEndOnOptions, type MaintainScrollAtEndOptions, type MaintainVisibleContentPositionConfig, type NativeScrollEvent, type NativeSyntheticEvent, type OnViewableItemsChanged, type OnViewableItemsChangedInfo, type ScrollIndexWithOffset, type ScrollIndexWithOffsetAndContentOffset, type ScrollIndexWithOffsetPosition, type StickyHeaderConfig, type StyleProp, type ViewAmountToken, type ViewStyle, type ViewToken, type ViewabilityAmountCallback, type ViewabilityCallback, type ViewabilityConfig, type ViewabilityConfigCallbackPair, type ViewabilityConfigCallbackPairs, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };