@legendapp/list 3.0.0-beta.4 → 3.0.0-beta.41

package/{types-YNdphn_A.d.mts → react.d.ts}

@@ -1,15 +1,79 @@
-import * as React$1 from 'react';
-import { ComponentProps, Key, ReactNode } from 'react';
-import { View, ScrollView, Animated, LayoutRectangle, ScrollViewComponent, ScrollResponderMixin, StyleProp, ViewStyle, NativeSyntheticEvent, NativeScrollEvent, ScrollViewProps } from 'react-native';
-import Reanimated from 'react-native-reanimated';
+import * as React from 'react';
+import { Key, ReactElement, HTMLAttributes, CSSProperties, Ref, RefAttributes, Dispatch, SetStateAction } from 'react';
+
+type ScrollEventTarget = Window | HTMLElement;
+
+interface ScrollViewMethods {
+    getBoundingClientRect(): DOMRect | null | undefined;
+    getContentNode(): HTMLElement | null;
+    getCurrentScrollOffset(): number;
+    getScrollableNode(): HTMLElement;
+    getScrollEventTarget(): ScrollEventTarget | null;
+    getScrollResponder(): HTMLElement | null;
+    isWindowScroll?(): boolean;
+    scrollBy(x: number, y: number): void;
+    scrollTo(options: {
+        x?: number;
+        y?: number;
+        animated?: boolean;
+    }): void;
+    scrollToEnd(options?: {
+        animated?: boolean;
+    }): void;
+    scrollToOffset(params: {
+        offset: number;
+        animated?: boolean;
+    }): void;
+}
 
 type AnimatedValue = number;
 
-type ListenerType = "numContainers" | "numContainersPooled" | `containerItemKey${number}` | `containerItemData${number}` | `containerPosition${number}` | `containerColumn${number}` | `containerSticky${number}` | `containerStickyOffset${number}` | "containersDidLayout" | "extraData" | "numColumns" | "lastItemKeys" | "totalSize" | "alignItemsPaddingTop" | "lastPositionUpdate" | "stylePaddingTop" | "scrollAdjust" | "scrollAdjustUserOffset" | "scrollAdjustPending" | "scrollingTo" | "headerSize" | "footerSize" | "maintainVisibleContentPosition" | "debugRawScroll" | "debugComputedScroll" | "otherAxisSize" | "snapToOffsets" | "scrollSize" | "activeStickyIndex";
+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 ListenerTypeValueMap = {
+    activeStickyIndex: number;
+    animatedScrollY: any;
+    debugComputedScroll: number;
+    debugRawScroll: number;
+    extraData: any;
+    footerSize: number;
+    headerSize: number;
+    lastItemKeys: string[];
+    lastPositionUpdate: number;
+    maintainVisibleContentPosition: MaintainVisibleContentPositionNormalized;
+    numColumns: number;
+    numContainers: number;
+    numContainersPooled: number;
+    otherAxisSize: number;
+    readyToRender: boolean;
+    scrollAdjust: number;
+    scrollAdjustPending: number;
+    scrollAdjustUserOffset: number;
+    scrollSize: {
+        width: number;
+        height: number;
+    };
+    snapToOffsets: number[];
+    stylePaddingTop: number;
+    totalSize: number;
+} & {
+    [K in ListenerType as K extends `containerItemKey${number}` ? K : never]: string;
+} & {
+    [K in ListenerType as K extends `containerItemData${number}` ? K : never]: any;
+} & {
+    [K in ListenerType as K extends `containerPosition${number}` ? K : never]: number;
+} & {
+    [K in ListenerType as K extends `containerColumn${number}` ? K : never]: number;
+} & {
+    [K in ListenerType as K extends `containerSpan${number}` ? K : never]: number;
+} & {
+    [K in ListenerType as K extends `containerSticky${number}` ? K : never]: boolean;
+};
 interface StateContext {
-    internalState: InternalState | undefined;
+    animatedScrollY: AnimatedValue;
+    columnWrapperStyle: ColumnWrapperStyle | undefined;
+    contextNum: number;
     listeners: Map<ListenerType, Set<(value: any) => void>>;
-    values: Map<ListenerType, any>;
     mapViewabilityCallbacks: Map<string, ViewabilityCallback>;
     mapViewabilityValues: Map<string, ViewToken>;
     mapViewabilityAmountCallbacks: Map<number, ViewabilityAmountCallback>;
@@ -21,22 +85,85 @@ interface StateContext {
         previousStart: number;
         previousEnd: number;
     }>;
-    columnWrapperStyle: ColumnWrapperStyle | undefined;
-    viewRefs: Map<number, React$1.RefObject<View>>;
-    animatedScrollY: AnimatedValue;
+    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 context;
-    private mounted;
+    private ctx;
     constructor(ctx: StateContext);
     requestAdjust(add: number): void;
-    setMounted(): 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;
+    left: number;
+    bottom: number;
+    right: number;
+}
+interface LayoutRectangle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface NativeScrollEvent {
+    contentOffset: {
+        x: number;
+        y: number;
+    };
+    contentSize: {
+        width: number;
+        height: number;
+    };
+    layoutMeasurement: {
+        width: number;
+        height: number;
+    };
+    contentInset: Insets;
+    zoomScale: number;
+}
+interface NativeSyntheticEvent<T> {
+    nativeEvent: 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> {
     /**
@@ -51,7 +178,7 @@ interface DataModeProps<ItemT, TItemType extends string | undefined> {
      * - A React component: React.ComponentType<LegendListRenderItemProps<ItemT>>
      * @required when using data mode
      */
-    renderItem: ((props: LegendListRenderItemProps<ItemT, TItemType>) => ReactNode) | React.ComponentType<LegendListRenderItemProps<ItemT, TItemType>>;
+    renderItem: ((props: LegendListRenderItemProps<ItemT, TItemType>) => React.ReactNode) | React.ComponentType<LegendListRenderItemProps<ItemT, TItemType>>;
     children?: never;
 }
 interface ChildrenModeProps {
@@ -60,7 +187,7 @@ interface ChildrenModeProps {
      * Each child will be treated as an individual list item.
      * @required when using children mode
      */
-    children: ReactNode;
+    children: React.ReactNode;
     data?: never;
     renderItem?: never;
 }
@@ -71,10 +198,10 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      */
     alignItemsAtEnd?: boolean;
     /**
-     * If true, enables using average sizes for performance optimization.
-     * @default true
+     * Keeps selected items mounted even when they scroll out of view.
+     * @default undefined
      */
-    enableAverages?: boolean;
+    alwaysRender?: AlwaysRenderConfig;
     /**
      * Style applied to each column's wrapper view.
      */
@@ -111,7 +238,14 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * 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, type: TItemType) => number;
+    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.
+     */
+    overrideItemLayout?: (layout: {
+        span?: number;
+    }, item: ItemT, index: number, maxColumns: number, extraData?: any) => void;
     /**
      * Ratio of initial container pool size to data length (e.g., 0.5 for half).
      * @default 2
@@ -129,6 +263,7 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
     initialScrollIndex?: number | {
         index: number;
         viewOffset?: number | undefined;
+        viewPosition?: number | undefined;
     };
     /**
      * When true, the list initializes scrolled to the last item.
@@ -168,6 +303,7 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
     ListHeaderComponentStyle?: StyleProp<ViewStyle> | undefined;
     /**
      * If true, auto-scrolls to end when new items are added.
+     * Use an options object to opt into specific triggers and control whether that scroll is animated.
      * @default false
      */
     maintainScrollAtEnd?: boolean | MaintainScrollAtEndOptions;
@@ -177,11 +313,19 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      */
     maintainScrollAtEndThreshold?: number;
     /**
-     * If true, maintains visibility of content across data changes (filtering/resorting/insertions).
-     * Scroll-time stability for measurements is always enabled.
+     * Maintains visibility of content.
+     * - scroll (default: true) stabilizes during size/layout changes while scrolling.
+     * - data (default: false) stabilizes when the data array changes; passing true also sets the RN maintainVisibleContentPosition prop.
+     * - shouldRestorePosition can opt out specific items from data-change anchoring.
+     * - undefined (default) enables scroll stabilization but skips data-change anchoring.
+     * - true enables both behaviors; false disables both.
+     */
+    maintainVisibleContentPosition?: boolean | MaintainVisibleContentPositionConfig<ItemT>;
+    /**
+     * Web only: when true, listens to window/body scrolling instead of rendering a scrollable list container.
      * @default false
      */
-    maintainVisibleContentPosition?: boolean;
+    useWindowScroll?: boolean;
     /**
      * Number of columns to render items in.
      * @default 1
@@ -208,6 +352,10 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
         itemKey: string;
         itemData: ItemT;
     }) => void;
+    /**
+     * Called when list layout metrics change.
+     */
+    onMetricsChange?: (metrics: LegendListMetrics) => void;
     /**
      * Function to call when the user pulls to refresh.
      */
@@ -248,7 +396,7 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
     /**
      * Ref to the underlying ScrollView component.
      */
-    refScrollView?: React.Ref<ScrollView>;
+    refScrollView?: React.Ref<any>;
     /**
      * If true, shows a refresh indicator.
      * @default false
@@ -259,7 +407,7 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Note: When using `stickyHeaderIndices`, you must provide an Animated ScrollView component.
      * @default (props) => <ScrollView {...props} />
      */
-    renderScrollComponent?: (props: ScrollViewProps) => React.ReactElement<ScrollViewProps>;
+    renderScrollComponent?: (props: any) => React.ReactElement | null;
     /**
      * This will log a suggested estimatedItemSize.
      * @required
@@ -294,22 +442,72 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * @deprecated Use stickyHeaderIndices instead for parity with React Native.
      */
     stickyIndices?: number[];
+    /**
+     * Configuration for sticky headers.
+     * @default undefined
+     */
+    stickyHeaderConfig?: StickyHeaderConfig;
     getItemType?: (item: ItemT, index: number) => TItemType;
-    getFixedItemSize?: (index: number, item: ItemT, type: TItemType) => number | undefined;
+    getFixedItemSize?: (item: ItemT, index: number, type: TItemType) => number | undefined;
     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 Reanimated.ScrollView>, TItemType extends string | undefined = string | undefined> = BaseScrollViewProps<TScrollView> & LegendListSpecificProps<ItemT, TItemType> & (DataModeProps<ItemT, TItemType> | ChildrenModeProps);
+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 StickyHeaderConfig {
+    /**
+     * Specifies how far from the top edge sticky headers should start sticking.
+     * Useful for scenarios with a fixed navbar or header, where sticky elements pin below it..
+     * @default 0
+     */
+    offset?: number;
+    /**
+     * Component to render as a backdrop behind the sticky header.
+     * @default undefined
+     */
+    backdropComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
+}
+interface AlwaysRenderConfig {
+    top?: number;
+    bottom?: number;
+    indices?: number[];
+    keys?: string[];
+}
+interface MaintainScrollAtEndOnOptions {
+    dataChange?: boolean;
+    itemLayout?: boolean;
+    layout?: boolean;
+}
 interface MaintainScrollAtEndOptions {
-    onLayout?: boolean;
-    onItemLayout?: boolean;
-    onDataChange?: boolean;
+    /**
+     * Whether maintainScrollAtEnd should animate when it scrolls to the end.
+     */
+    animated?: boolean;
+    /**
+     * Which events should keep the list pinned to the end.
+     * - If omitted, object values default to all triggers.
+     * - If provided, only the keys set to `true` are enabled.
+     */
+    on?: MaintainScrollAtEndOnOptions;
 }
 interface ColumnWrapperStyle {
     rowGap?: number;
     gap?: number;
     columnGap?: number;
 }
-type LegendListProps<ItemT = any> = LegendListPropsBase<ItemT, ComponentProps<typeof ScrollView>>;
+interface LegendListMetrics {
+    headerSize: number;
+    footerSize: number;
+}
 interface ThresholdSnapshot {
     scrollPosition: number;
     contentSize?: number;
@@ -317,167 +515,222 @@ interface ThresholdSnapshot {
     atThreshold: boolean;
 }
 interface ScrollTarget {
-    offset: number;
-    index?: number;
-    viewOffset?: number;
-    viewPosition?: number;
     animated?: boolean;
+    index?: number;
     isInitialScroll?: boolean;
+    itemSize?: number;
+    offset: number;
     precomputedWithViewOffset?: boolean;
+    targetOffset?: number;
+    viewOffset?: number;
+    viewPosition?: number;
 }
 interface InternalState {
-    positions: Map<string, number>;
-    columns: Map<string, number>;
-    sizes: Map<string, number>;
-    sizesKnown: Map<string, number>;
-    containerItemKeys: Set<string>;
+    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>;
-    isStartReached: boolean;
-    isEndReached: boolean;
-    isAtEnd: boolean;
-    isAtStart: boolean;
-    hasScrolled?: boolean;
-    scrollLength: number;
-    startBuffered: number;
-    startBufferedId?: string;
-    startNoBuffer: number;
+    dataChangeEpoch: number;
+    dataChangeNeedsScrollUpdate: boolean;
+    didColumnsChange?: boolean;
+    didDataChange?: boolean;
+    didFinishInitialScroll?: boolean;
+    didContainersLayout?: boolean;
+    enableScrollForNextCalculateItemsInView: boolean;
     endBuffered: number;
     endNoBuffer: number;
+    endReachedSnapshot: ThresholdSnapshot | undefined;
     firstFullyOnScreenIndex: number;
-    idsInView: string[];
-    scrollPending: number;
-    scroll: number;
-    scrollTime: number;
-    scrollPrev: number;
-    scrollPrevTime: number;
-    scrollAdjustHandler: ScrollAdjustHandler;
-    triggerCalculateItemsInView?: (params?: {
-        doMVCP?: boolean;
-        dataChanged?: boolean;
-        forceFullItemPositions?: boolean;
-    }) => void;
-    maintainingScrollAtEnd?: boolean;
-    totalSize: number;
-    otherAxisSize?: number;
-    timeouts: Set<number>;
-    timeoutSizeMessage: any;
-    nativeMarginTop: number;
-    indexByKey: Map<string, number>;
+    hasScrolled?: boolean;
     idCache: string[];
-    viewabilityConfigCallbackPairs: ViewabilityConfigCallbackPairs<any> | undefined;
-    scrollHistory: Array<{
-        scroll: number;
-        time: number;
-    }>;
-    lastScrollAdjustForHistory?: number;
-    startReachedSnapshot: ThresholdSnapshot | undefined;
-    endReachedSnapshot: ThresholdSnapshot | undefined;
-    scrollForNextCalculateItemsInView: {
-        top: number;
-        bottom: number;
-    } | undefined;
-    enableScrollForNextCalculateItemsInView: boolean;
-    minIndexSizeChanged: number | undefined;
-    queuedInitialLayout?: boolean | undefined;
-    queuedCalculateItemsInView: number | undefined;
-    dataChangeNeedsScrollUpdate: boolean;
-    previousData?: readonly unknown[];
-    didColumnsChange?: boolean;
-    didDataChange?: boolean;
-    isFirst?: boolean;
-    lastBatchingAction: number;
+    idsInView: string[];
     ignoreScrollFromMVCP?: {
         lt?: number;
         gt?: number;
     };
     ignoreScrollFromMVCPIgnored?: boolean;
     ignoreScrollFromMVCPTimeout?: any;
-    needsOtherAxisSize?: boolean;
-    averageSizes: Record<string, {
-        num: number;
-        avg: number;
-    }>;
-    refScroller: React.RefObject<ScrollView>;
-    loadStartTime: number;
-    initialScroll: ScrollIndexWithOffsetAndContentOffset | undefined;
+    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;
-    timeoutSetPaddingTop?: any;
-    activeStickyIndex: number | undefined;
-    stickyContainers: Map<number, number>;
-    stickyContainerPool: Set<number>;
-    scrollProcessingEnabled: boolean;
+    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;
+        closestDistanceToClamp: number;
+        hasApproachedClamp: boolean;
+        manualApplied: number;
+        startScroll: number;
+    };
+    pendingMaintainScrollAtEnd?: boolean;
     pendingTotalSize?: number;
-    adjustingFromInitialMount?: 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: LegendListProps["getEstimatedItemSize"];
-        getFixedItemSize: LegendListProps["getFixedItemSize"];
-        getItemType: LegendListProps["getItemType"];
+        getEstimatedItemSize: LegendListPropsInternal["getEstimatedItemSize"];
+        getFixedItemSize: LegendListPropsInternal["getFixedItemSize"];
+        getItemType: LegendListPropsInternal["getItemType"];
         horizontal: boolean;
-        keyExtractor: LegendListProps["keyExtractor"];
-        maintainScrollAtEnd: boolean | MaintainScrollAtEndOptions;
+        initialContainerPoolRatio: number;
+        itemsAreEqual: LegendListPropsInternal["itemsAreEqual"];
+        keyExtractor: LegendListPropsInternal["keyExtractor"];
+        maintainScrollAtEnd: MaintainScrollAtEndNormalized | undefined;
         maintainScrollAtEndThreshold: number | undefined;
-        maintainVisibleContentPosition: boolean;
-        onEndReached: LegendListProps["onEndReached"];
+        maintainVisibleContentPosition: MaintainVisibleContentPositionNormalized;
+        numColumns: number;
+        onEndReached: LegendListPropsInternal["onEndReached"];
         onEndReachedThreshold: number | null | undefined;
-        onItemSizeChanged: LegendListProps["onItemSizeChanged"];
-        onLoad: LegendListProps["onLoad"];
-        onScroll: LegendListProps["onScroll"];
-        onStartReached: LegendListProps["onStartReached"];
+        onItemSizeChanged: LegendListPropsInternal["onItemSizeChanged"];
+        onLoad: LegendListPropsInternal["onLoad"];
+        onScroll: LegendListPropsInternal["onScroll"];
+        onStartReached: LegendListPropsInternal["onStartReached"];
         onStartReachedThreshold: number | null | undefined;
-        onStickyHeaderChange: LegendListProps["onStickyHeaderChange"];
+        onStickyHeaderChange: LegendListPropsInternal["onStickyHeaderChange"];
+        overrideItemLayout: LegendListPropsInternal["overrideItemLayout"];
         recycleItems: boolean;
-        suggestEstimatedItemSize: boolean;
-        stylePaddingBottom: number | undefined;
-        renderItem: LegendListProps["renderItem"];
-        scrollBuffer: number;
-        numColumns: number;
-        initialContainerPoolRatio: number;
-        stylePaddingTop: number | undefined;
+        renderItem: LegendListPropsInternal["renderItem"];
+        scrollBuffer?: number;
         snapToIndices: number[] | undefined;
-        stickyIndicesSet: Set<number>;
+        positionComponentInternal: React.ComponentType<any> | undefined;
+        stickyPositionComponentInternal: React.ComponentType<any> | undefined;
         stickyIndicesArr: number[];
-        itemsAreEqual: LegendListProps["itemsAreEqual"];
-        enableAverages: boolean;
+        stickyIndicesSet: Set<number>;
+        stylePaddingBottom: number | undefined;
+        stylePaddingTop: number | undefined;
+        suggestEstimatedItemSize: boolean;
+        useWindowScroll: boolean;
     };
 }
 interface ViewableRange<T> {
-    startBuffered: number;
-    start: number;
-    endBuffered: number;
     end: number;
+    endBuffered: number;
     items: T[];
+    start: number;
+    startBuffered: number;
 }
 interface LegendListRenderItemProps<ItemT, TItemType extends string | number | undefined = string | number | undefined> {
-    item: ItemT;
-    type: TItemType;
-    index: number;
     data: readonly ItemT[];
     extraData: any;
+    index: number;
+    item: ItemT;
+    type: TItemType;
 }
-type ScrollState = {
-    activeStickyIndex: number | undefined;
+type LegendListState$1 = {
+    activeStickyIndex: number;
     contentLength: number;
     data: readonly any[];
-    elementAtIndex: (index: number) => View | null | undefined;
+    elementAtIndex: (index: number) => any;
     end: number;
     endBuffered: number;
     isAtEnd: boolean;
     isAtStart: boolean;
+    isEndReached: boolean;
+    isStartReached: 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;
-    positions: Map<string, number>;
+    positionByKey: (key: string) => number | undefined;
     scroll: number;
     scrollLength: number;
+    scrollVelocity: number;
     sizeAtIndex: (index: number) => number;
     sizes: Map<string, number>;
     start: number;
     startBuffered: number;
 };
-type LegendListRef = {
+type LegendListRef$1 = {
     /**
      * Displays the scroll indicators momentarily.
      */
@@ -485,7 +738,7 @@ type LegendListRef = {
     /**
      * Returns the native ScrollView component reference.
      */
-    getNativeScrollRef(): React.ElementRef<typeof ScrollViewComponent>;
+    getNativeScrollRef(): any;
     /**
      * Returns the scroll responder instance for handling scroll events.
      */
@@ -493,11 +746,11 @@ type LegendListRef = {
     /**
      * Returns the ScrollResponderMixin for advanced scroll handling.
      */
-    getScrollResponder(): ScrollResponderMixin;
+    getScrollResponder(): any;
     /**
      * Returns the internal state of the scroll virtualization.
      */
-    getState(): ScrollState;
+    getState(): LegendListState$1;
     /**
      * Scrolls a specific index into view.
      * @param params - Parameters for scrolling.
@@ -507,7 +760,7 @@ type LegendListRef = {
     scrollIndexIntoView(params: {
         animated?: boolean | undefined;
         index: number;
-    }): void;
+    }): Promise<void>;
     /**
      * Scrolls a specific index into view.
      * @param params - Parameters for scrolling.
@@ -517,7 +770,7 @@ type LegendListRef = {
     scrollItemIntoView(params: {
         animated?: boolean | undefined;
         item: any;
-    }): void;
+    }): Promise<void>;
     /**
      * Scrolls to the end of the list.
      * @param options - Options for scrolling.
@@ -527,7 +780,7 @@ type LegendListRef = {
     scrollToEnd(options?: {
         animated?: boolean | undefined;
         viewOffset?: number | undefined;
-    }): void;
+    }): Promise<void>;
     /**
      * Scrolls to a specific index in the list.
      * @param params - Parameters for scrolling.
@@ -541,7 +794,7 @@ type LegendListRef = {
         index: number;
         viewOffset?: number | undefined;
         viewPosition?: number | undefined;
-    }): void;
+    }): Promise<void>;
     /**
      * Scrolls to a specific item in the list.
      * @param params - Parameters for scrolling.
@@ -555,7 +808,7 @@ type LegendListRef = {
         item: any;
         viewOffset?: number | undefined;
         viewPosition?: number | undefined;
-    }): void;
+    }): Promise<void>;
     /**
      * Scrolls to a specific offset in pixels.
      * @param params - Parameters for scrolling.
@@ -565,36 +818,49 @@ type LegendListRef = {
     scrollToOffset(params: {
         offset: number;
         animated?: boolean | undefined;
-    }): void;
+    }): Promise<void>;
     /**
      * Sets or adds to the offset of the visible content anchor.
      * @param value - The offset to set or add.
      * @param animated - If true, uses Animated to animate the change.
      */
-    setVisibleContentAnchorOffset(value: number | ((value: number) => number)): void;
+    setVisibleContentAnchorOffset(value: number | ((val: number) => number)): void;
     /**
      * Sets whether scroll processing is enabled.
      * @param enabled - If true, scroll processing is enabled.
      */
     setScrollProcessingEnabled(enabled: boolean): void;
+    /**
+     * Clears internal virtualization caches.
+     * @param options - Cache clearing options.
+     * @param options.mode - `sizes` clears measurement caches. `full` also clears key/position caches.
+     */
+    clearCaches(options?: {
+        mode?: "sizes" | "full";
+    }): void;
+    /**
+     * Reports an externally measured content inset. Pass null/undefined to clear.
+     * Values are merged on top of props/animated/native insets.
+     */
+    reportContentInset(inset?: Partial<Insets> | null): void;
 };
 interface ViewToken<ItemT = any> {
-    item: ItemT;
-    key: string;
+    containerId: number;
     index: number;
     isViewable: boolean;
-    containerId: number;
+    item: ItemT;
+    key: string;
 }
 interface ViewAmountToken<ItemT = any> extends ViewToken<ItemT> {
-    sizeVisible: number;
-    size: number;
-    percentVisible: number;
     percentOfScroller: number;
+    percentVisible: number;
     scrollSize: number;
+    size: number;
+    sizeVisible: number;
 }
 interface ViewabilityConfigCallbackPair<ItemT = any> {
-    viewabilityConfig: ViewabilityConfig;
     onViewableItemsChanged?: OnViewableItemsChanged<ItemT>;
+    viewabilityConfig: ViewabilityConfig;
 }
 type ViewabilityConfigCallbackPairs<ItemT> = ViewabilityConfigCallbackPair<ItemT>[];
 type OnViewableItemsChanged<ItemT> = ((info: {
@@ -633,14 +899,14 @@ interface ViewabilityConfig {
 type ViewabilityCallback<ItemT = any> = (viewToken: ViewToken<ItemT>) => void;
 type ViewabilityAmountCallback<ItemT = any> = (viewToken: ViewAmountToken<ItemT>) => void;
 interface LegendListRecyclingState<T> {
-    item: T;
-    prevItem: T | undefined;
     index: number;
+    item: T;
     prevIndex: number | undefined;
+    prevItem: T | undefined;
 }
-type TypedForwardRef = <T, P = {}>(render: (props: P, ref: React.Ref<T>) => React.ReactNode) => (props: P & React.RefAttributes<T>) => React.ReactNode;
+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.JSXElementConstructor<T>>, nextProps: Readonly<React.JSXElementConstructor<T>>) => boolean) => T & {
+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;
@@ -667,4 +933,73 @@ type GetRenderedItemResult<ItemT> = {
 };
 type GetRenderedItem = (key: string) => GetRenderedItemResult<any> | null;
 
-export { type ColumnWrapperStyle as C, type GetRenderedItemResult as G, type InternalState as I, type LegendListProps as L, type MaintainScrollAtEndOptions as M, type OnViewableItemsChanged as O, type ScrollTarget as S, type ThresholdSnapshot as T, type ViewabilityCallback as V, type LegendListRef as a, type ViewabilityAmountCallback as b, type LegendListRecyclingState as c, type LegendListPropsBase as d, type ViewableRange as e, type LegendListRenderItemProps as f, type ScrollState as g, type ViewToken as h, type ViewAmountToken as i, type ViewabilityConfigCallbackPair as j, type ViewabilityConfigCallbackPairs as k, type ViewabilityConfig as l, type TypedForwardRef as m, type TypedMemo as n, typedMemo as o, type ScrollIndexWithOffset as p, type ScrollIndexWithOffsetPosition as q, type ScrollIndexWithOffsetAndContentOffset as r, type InitialScrollAnchor as s, typedForwardRef as t, type GetRenderedItem as u };
+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 {
+    contentContainerStyle?: StyleProp<ViewStyle>;
+    contentInset?: Insets;
+    contentOffset?: {
+        x: number;
+        y: number;
+    };
+    horizontal?: boolean;
+    maintainVisibleContentPosition?: {
+        autoscrollToTopThreshold?: number;
+        minIndexForVisible: number;
+    };
+    onLayout?: (event: LooseLayoutChangeEvent) => void;
+    onMomentumScrollBegin?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    onMomentumScrollEnd?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    onScroll?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    refreshControl?: ReactElement | null;
+    removeClippedSubviews?: boolean;
+    scrollEventThrottle?: number;
+    showsHorizontalScrollIndicator?: boolean;
+    showsVerticalScrollIndicator?: boolean;
+    stickyHeaderIndices?: number[];
+    style?: StyleProp<ViewStyle>;
+}
+
+type ScrollViewPropsWeb = Omit<LooseScrollViewProps, "style" | "contentContainerStyle" | "onScroll" | "onLayout" | "pagingEnabled" | "snapToInterval"> & Omit<HTMLAttributes<HTMLDivElement>, "onScroll" | "onLayout" | "style"> & {
+    style?: CSSProperties;
+    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"> & {
+    refScrollView?: Ref<HTMLElement | ScrollViewMethods>;
+    ListHeaderComponentStyle?: CSSProperties | undefined;
+    ListFooterComponentStyle?: CSSProperties | undefined;
+};
+type LegendListProps<ItemT = any, TItemType extends string | undefined = string | undefined> = LegendListPropsOverrides<ItemT, TItemType>;
+type LegendListRef = Omit<LegendListRef$1, "getNativeScrollRef" | "getScrollableNode" | "getScrollResponder"> & {
+    getNativeScrollRef(): HTMLElement | ScrollViewMethods;
+    getScrollableNode(): HTMLElement;
+    getScrollResponder(): HTMLElement | null;
+};
+type LegendListState = Omit<LegendListState$1, "elementAtIndex"> & {
+    elementAtIndex: (index: number) => HTMLElement | null | undefined;
+};
+type LegendListComponent = <ItemT = any>(props: LegendListProps<ItemT> & RefAttributes<LegendListRef>) => ReactElement | null;
+
+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, Dispatch<SetStateAction<ItemT>>];
+declare function useIsLastItem(): boolean;
+declare function useListScrollSize(): {
+    width: number;
+    height: number;
+};
+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 };