@legendapp/list 3.0.0-beta.32 → 3.0.0-beta.34

package/index.d.ts

@@ -1,10 +1,13 @@
 import * as React$1 from 'react';
-import { Key, ComponentProps, ReactNode, Dispatch, SetStateAction } from 'react';
-import { View, LayoutRectangle, Insets, ScrollView, ScrollViewProps, Animated, StyleProp, ViewStyle, NativeSyntheticEvent, NativeScrollEvent, ScrollViewComponent, ScrollResponderMixin } from 'react-native';
-import Reanimated from 'react-native-reanimated';
+import { Key, ReactNode, ComponentType, CSSProperties, Ref, ReactElement, JSXElementConstructor, RefAttributes, Dispatch, SetStateAction } from 'react';
 
 type AnimatedValue = number;
 
+type LooseMeasureCallback = (x: number, y: number, width: number, height: number, pageX: number, pageY: number) => void;
+interface LooseView {
+    measure?: (callback: LooseMeasureCallback) => void;
+}
+
 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 = {
@@ -17,7 +20,7 @@ type ListenerTypeValueMap = {
     headerSize: number;
     lastItemKeys: string[];
     lastPositionUpdate: number;
-    maintainVisibleContentPosition: MaintainVisibleContentPositionNormalized;
+    maintainVisibleContentPosition: MaintainVisibleContentPositionNormalized$1;
     numColumns: number;
     numContainers: number;
     numContainersPooled: number;
@@ -48,24 +51,24 @@ type ListenerTypeValueMap = {
 };
 interface StateContext {
     animatedScrollY: AnimatedValue;
-    columnWrapperStyle: ColumnWrapperStyle | undefined;
+    columnWrapperStyle: ColumnWrapperStyle$1 | 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>;
+    mapViewabilityCallbacks: Map<string, ViewabilityCallback$1>;
+    mapViewabilityValues: Map<string, ViewToken$1>;
+    mapViewabilityAmountCallbacks: Map<number, ViewabilityAmountCallback$1>;
+    mapViewabilityAmountValues: Map<number, ViewAmountToken$1>;
     mapViewabilityConfigStates: Map<string, {
-        viewableItems: ViewToken[];
+        viewableItems: ViewToken$1[];
         start: number;
         end: number;
         previousStart: number;
         previousEnd: number;
     }>;
     positionListeners: Map<string, Set<(value: any) => void>>;
-    state: InternalState;
+    state: InternalState$1;
     values: Map<ListenerType, any>;
-    viewRefs: Map<number, React$1.RefObject<View>>;
+    viewRefs: Map<number, React$1.RefObject<LooseView>>;
 }
 
 declare class ScrollAdjustHandler {
@@ -75,7 +78,7 @@ declare class ScrollAdjustHandler {
     constructor(ctx: StateContext);
     requestAdjust(add: number): void;
     getAdjust(): number;
-    commitPendingAdjust(scrollTarget: ScrollTarget): void;
+    commitPendingAdjust(scrollTarget: ScrollTarget$1): void;
 }
 
 type BaseSharedValue<T = number> = {
@@ -85,7 +88,63 @@ type StylesAsSharedValue<Style> = {
     [key in keyof Style]: Style[key] | BaseSharedValue<Style[key]>;
 };
 
-type BaseScrollViewProps<TScrollView> = Omit<TScrollView, "contentOffset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children" | "onScroll">;
+interface Insets$1 {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+}
+interface LayoutRectangle$1 {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface NativeScrollEvent$1 {
+    contentOffset: {
+        x: number;
+        y: number;
+    };
+    contentSize: {
+        width: number;
+        height: number;
+    };
+    layoutMeasurement: {
+        width: number;
+        height: number;
+    };
+    contentInset: Insets$1;
+    zoomScale: number;
+}
+interface NativeSyntheticEvent$1<T> {
+    nativeEvent: T;
+}
+type ViewStyle$1 = Record<string, unknown>;
+type StyleProp$1<T> = T | T[] | null | undefined | false;
+interface ScrollEventTargetLike$1 {
+    addEventListener(type: string, listener: (...args: any[]) => void): void;
+    removeEventListener(type: string, listener: (...args: any[]) => void): void;
+}
+interface ScrollableNodeLike$1 {
+    scrollLeft?: number;
+    scrollTop?: number;
+}
+interface LegendListScrollerRef$1 {
+    flashScrollIndicators(): void;
+    getCurrentScrollOffset?(): number;
+    getScrollEventTarget(): ScrollEventTargetLike$1 | null;
+    getScrollableNode(): ScrollableNodeLike$1 | null;
+    getScrollResponder(): unknown;
+    scrollTo(options: {
+        animated?: boolean;
+        x?: number;
+        y?: number;
+    }): void;
+    scrollToEnd(options?: {
+        animated?: boolean;
+    }): void;
+}
+type BaseScrollViewProps$1<TScrollView> = Omit<TScrollView, "contentOffset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children" | "onScroll">;
 interface DataModeProps<ItemT, TItemType extends string | undefined> {
     /**
      * Array of items to render in the list.
@@ -99,7 +158,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$1<ItemT, TItemType>) => ReactNode) | React.ComponentType<LegendListRenderItemProps$1<ItemT, TItemType>>;
     children?: never;
 }
 interface ChildrenModeProps {
@@ -122,11 +181,11 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Keeps selected items mounted even when they scroll out of view.
      * @default undefined
      */
-    alwaysRender?: AlwaysRenderConfig;
+    alwaysRender?: AlwaysRenderConfig$1;
     /**
      * Style applied to each column's wrapper view.
      */
-    columnWrapperStyle?: ColumnWrapperStyle;
+    columnWrapperStyle?: ColumnWrapperStyle$1;
     /**
      * Distance in pixels to pre-render items ahead of the visible area.
      * @default 250
@@ -213,7 +272,7 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
     /**
      * Style for the footer component.
      */
-    ListFooterComponentStyle?: StyleProp<ViewStyle> | undefined;
+    ListFooterComponentStyle?: StyleProp$1<ViewStyle$1> | undefined;
     /**
      * Component or element to render above the list.
      */
@@ -221,12 +280,12 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
     /**
      * Style for the header component.
      */
-    ListHeaderComponentStyle?: StyleProp<ViewStyle> | undefined;
+    ListHeaderComponentStyle?: StyleProp$1<ViewStyle$1> | undefined;
     /**
      * If true, auto-scrolls to end when new items are added.
      * @default false
      */
-    maintainScrollAtEnd?: boolean | MaintainScrollAtEndOptions;
+    maintainScrollAtEnd?: boolean | MaintainScrollAtEndOptions$1;
     /**
      * Distance threshold in percentage of screen size to trigger maintainScrollAtEnd.
      * @default 0.1
@@ -240,7 +299,12 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * - undefined (default) enables scroll stabilization but skips data-change anchoring.
      * - true enables both behaviors; false disables both.
      */
-    maintainVisibleContentPosition?: boolean | MaintainVisibleContentPositionConfig<ItemT>;
+    maintainVisibleContentPosition?: boolean | MaintainVisibleContentPositionConfig$1<ItemT>;
+    /**
+     * Web only: when true, listens to window/body scrolling instead of rendering a scrollable list container.
+     * @default false
+     */
+    useWindowScroll?: boolean;
     /**
      * Number of columns to render items in.
      * @default 1
@@ -270,12 +334,12 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
     /**
      * Called when list layout metrics change.
      */
-    onMetricsChange?: (metrics: LegendListMetrics) => void;
+    onMetricsChange?: (metrics: LegendListMetrics$1) => void;
     /**
      * Function to call when the user pulls to refresh.
      */
     onRefresh?: () => void;
-    onScroll?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    onScroll?: (event: NativeSyntheticEvent$1<NativeScrollEvent$1>) => void;
     /**
      * Called when scrolling reaches the start within onStartReachedThreshold.
      */
@@ -297,7 +361,7 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
     /**
      * Called when the viewability of items changes.
      */
-    onViewableItemsChanged?: OnViewableItemsChanged<ItemT> | undefined;
+    onViewableItemsChanged?: OnViewableItemsChanged$1<ItemT> | undefined;
     /**
      * Offset in pixels for the refresh indicator.
      * @default 0
@@ -311,7 +375,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
@@ -322,7 +386,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
@@ -332,11 +396,11 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
     /**
      * Configuration for determining item viewability.
      */
-    viewabilityConfig?: ViewabilityConfig;
+    viewabilityConfig?: ViewabilityConfig$1;
     /**
      * Pairs of viewability configs and their callbacks for tracking visibility.
      */
-    viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs<ItemT> | undefined;
+    viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs$1<ItemT> | undefined;
     /**
      * If true, delays rendering until initial layout is complete.
      * @default false
@@ -361,23 +425,24 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Configuration for sticky headers.
      * @default undefined
      */
-    stickyHeaderConfig?: StickyHeaderConfig;
+    stickyHeaderConfig?: StickyHeaderConfig$1;
     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;
 }
-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);
-interface MaintainVisibleContentPositionConfig<ItemT = any> {
+type LegendListPropsBase$1<ItemT, TScrollViewProps = Record<string, any>, TItemType extends string | undefined = string | undefined> = BaseScrollViewProps$1<TScrollViewProps> & LegendListSpecificProps<ItemT, TItemType> & (DataModeProps<ItemT, TItemType> | ChildrenModeProps);
+type LegendListPropsInternal = LegendListSpecificProps<any, string | undefined> & DataModeProps<any, string | undefined>;
+interface MaintainVisibleContentPositionConfig$1<ItemT = any> {
     data?: boolean;
     size?: boolean;
     shouldRestorePosition?: (item: ItemT, index: number, data: readonly ItemT[]) => boolean;
 }
-interface MaintainVisibleContentPositionNormalized<ItemT = any> {
+interface MaintainVisibleContentPositionNormalized$1<ItemT = any> {
     data: boolean;
     size: boolean;
     shouldRestorePosition?: (item: ItemT, index: number, data: readonly ItemT[]) => boolean;
 }
-interface StickyHeaderConfig {
+interface StickyHeaderConfig$1 {
     /**
      * 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..
@@ -390,34 +455,33 @@ interface StickyHeaderConfig {
      */
     backdropComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
 }
-interface AlwaysRenderConfig {
+interface AlwaysRenderConfig$1 {
     top?: number;
     bottom?: number;
     indices?: number[];
     keys?: string[];
 }
-interface MaintainScrollAtEndOptions {
+interface MaintainScrollAtEndOptions$1 {
     onLayout?: boolean;
     onItemLayout?: boolean;
     onDataChange?: boolean;
 }
-interface ColumnWrapperStyle {
+interface ColumnWrapperStyle$1 {
     rowGap?: number;
     gap?: number;
     columnGap?: number;
 }
-interface LegendListMetrics {
+interface LegendListMetrics$1 {
     headerSize: number;
     footerSize: number;
 }
-type LegendListProps<ItemT = any> = LegendListPropsBase<ItemT, ComponentProps<typeof ScrollView>>;
-interface ThresholdSnapshot {
+interface ThresholdSnapshot$1 {
     scrollPosition: number;
     contentSize?: number;
     dataLength?: number;
     atThreshold: boolean;
 }
-interface ScrollTarget {
+interface ScrollTarget$1 {
     animated?: boolean;
     index?: number;
     isInitialScroll?: boolean;
@@ -427,7 +491,7 @@ interface ScrollTarget {
     viewOffset?: number;
     viewPosition?: number;
 }
-interface InternalState {
+interface InternalState$1 {
     activeStickyIndex: number | undefined;
     adjustingFromInitialMount?: number;
     animFrameCheckFinishedScroll?: any;
@@ -435,10 +499,11 @@ interface InternalState {
         num: number;
         avg: number;
     }>;
-    columns: Map<string, number>;
-    columnSpans: Map<string, 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;
@@ -447,7 +512,7 @@ interface InternalState {
     enableScrollForNextCalculateItemsInView: boolean;
     endBuffered: number;
     endNoBuffer: number;
-    endReachedSnapshot: ThresholdSnapshot | undefined;
+    endReachedSnapshot: ThresholdSnapshot$1 | undefined;
     firstFullyOnScreenIndex: number;
     hasScrolled?: boolean;
     idCache: string[];
@@ -459,15 +524,15 @@ interface InternalState {
     ignoreScrollFromMVCPIgnored?: boolean;
     ignoreScrollFromMVCPTimeout?: any;
     indexByKey: Map<string, number>;
-    initialAnchor?: InitialScrollAnchor;
-    initialScroll: ScrollIndexWithOffsetAndContentOffset | undefined;
+    initialAnchor?: InitialScrollAnchor$1;
+    initialScroll: ScrollIndexWithOffsetAndContentOffset$1 | undefined;
     isAtEnd: boolean;
     isAtStart: boolean;
     isEndReached: boolean | null;
     isFirst?: boolean;
     isStartReached: boolean | null;
     lastBatchingAction: number;
-    lastLayout: LayoutRectangle | undefined;
+    lastLayout: LayoutRectangle$1 | undefined;
     lastScrollAdjustForHistory?: number;
     lastScrollDelta: number;
     loadStartTime: number;
@@ -479,18 +544,19 @@ interface InternalState {
         quietPasses: number;
         expiresAt: number;
     };
-    contentInsetOverride?: Partial<Insets> | null;
-    nativeContentInset?: Insets;
+    contentInsetOverride?: Partial<Insets$1> | null;
+    nativeContentInset?: Insets$1;
     nativeMarginTop: number;
     needsOtherAxisSize?: boolean;
     otherAxisSize?: number;
     pendingTotalSize?: number;
-    positions: Map<string, number>;
+    pendingScrollResolve?: (() => void) | undefined;
+    positions: Array<number | undefined>;
     previousData?: readonly unknown[];
     queuedCalculateItemsInView: number | undefined;
     queuedMVCPRecalculate?: number;
     queuedInitialLayout?: boolean | undefined;
-    refScroller: React.RefObject<ScrollView>;
+    refScroller: React.RefObject<LegendListScrollerRef$1 | null>;
     scroll: number;
     scrollAdjustHandler: ScrollAdjustHandler;
     scrollForNextCalculateItemsInView: {
@@ -501,7 +567,7 @@ interface InternalState {
         scroll: number;
         time: number;
     }>;
-    scrollingTo?: ScrollTarget | undefined;
+    scrollingTo?: ScrollTarget$1 | undefined;
     scrollLastCalculate?: number;
     scrollLength: number;
     scrollPending: number;
@@ -514,7 +580,8 @@ interface InternalState {
     startBuffered: number;
     startBufferedId?: string;
     startNoBuffer: number;
-    startReachedSnapshot: ThresholdSnapshot | undefined;
+    startReachedSnapshotDataChangeEpoch: number | undefined;
+    startReachedSnapshot: ThresholdSnapshot$1 | undefined;
     stickyContainerPool: Set<number>;
     stickyContainers: Map<number, number>;
     timeouts: Set<number>;
@@ -527,67 +594,71 @@ interface InternalState {
         dataChanged?: boolean;
         forceFullItemPositions?: boolean;
     }) => void;
-    viewabilityConfigCallbackPairs: ViewabilityConfigCallbackPairs<any> | undefined;
+    viewabilityConfigCallbackPairs: ViewabilityConfigCallbackPairs$1<any> | undefined;
     props: {
         alignItemsAtEnd: boolean;
-        animatedProps: StylesAsSharedValue<ScrollViewProps>;
-        alwaysRender: AlwaysRenderConfig | undefined;
+        animatedProps: StylesAsSharedValue<Record<string, any>>;
+        alwaysRender: AlwaysRenderConfig$1 | undefined;
         alwaysRenderIndicesArr: number[];
         alwaysRenderIndicesSet: Set<number>;
-        contentInset: Insets | undefined;
+        contentInset: Insets$1 | 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;
         initialContainerPoolRatio: number;
-        itemsAreEqual: LegendListProps["itemsAreEqual"];
-        keyExtractor: LegendListProps["keyExtractor"];
-        maintainScrollAtEnd: boolean | MaintainScrollAtEndOptions;
+        itemsAreEqual: LegendListPropsInternal["itemsAreEqual"];
+        keyExtractor: LegendListPropsInternal["keyExtractor"];
+        maintainScrollAtEnd: boolean | MaintainScrollAtEndOptions$1;
         maintainScrollAtEndThreshold: number | undefined;
-        maintainVisibleContentPosition: MaintainVisibleContentPositionNormalized;
+        maintainVisibleContentPosition: MaintainVisibleContentPositionNormalized$1;
         numColumns: number;
-        onEndReached: LegendListProps["onEndReached"];
+        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"];
-        overrideItemLayout: LegendListProps["overrideItemLayout"];
+        onStickyHeaderChange: LegendListPropsInternal["onStickyHeaderChange"];
+        overrideItemLayout: LegendListPropsInternal["overrideItemLayout"];
         recycleItems: boolean;
-        renderItem: LegendListProps["renderItem"];
+        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> {
+interface ViewableRange$1<T> {
     end: number;
     endBuffered: number;
     items: T[];
     start: number;
     startBuffered: number;
 }
-interface LegendListRenderItemProps<ItemT, TItemType extends string | number | undefined = string | number | undefined> {
+interface LegendListRenderItemProps$1<ItemT, TItemType extends string | number | undefined = string | number | undefined> {
     data: readonly ItemT[];
     extraData: any;
     index: number;
     item: ItemT;
     type: TItemType;
 }
-type LegendListState = {
+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;
@@ -595,7 +666,7 @@ type LegendListState = {
     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;
@@ -604,7 +675,7 @@ type LegendListState = {
     start: number;
     startBuffered: number;
 };
-type LegendListRef = {
+type LegendListRef$1 = {
     /**
      * Displays the scroll indicators momentarily.
      */
@@ -612,7 +683,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.
      */
@@ -620,11 +691,11 @@ type LegendListRef = {
     /**
      * Returns the ScrollResponderMixin for advanced scroll handling.
      */
-    getScrollResponder(): ScrollResponderMixin;
+    getScrollResponder(): any;
     /**
      * Returns the internal state of the scroll virtualization.
      */
-    getState(): LegendListState;
+    getState(): LegendListState$1;
     /**
      * Scrolls a specific index into view.
      * @param params - Parameters for scrolling.
@@ -634,7 +705,7 @@ type LegendListRef = {
     scrollIndexIntoView(params: {
         animated?: boolean | undefined;
         index: number;
-    }): void;
+    }): Promise<void>;
     /**
      * Scrolls a specific index into view.
      * @param params - Parameters for scrolling.
@@ -644,7 +715,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.
@@ -654,7 +725,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.
@@ -668,7 +739,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.
@@ -682,7 +753,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.
@@ -692,7 +763,7 @@ 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.
@@ -704,36 +775,44 @@ type LegendListRef = {
      * @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;
+    reportContentInset(inset?: Partial<Insets$1> | null): void;
 };
-interface ViewToken<ItemT = any> {
+interface ViewToken$1<ItemT = any> {
     containerId: number;
     index: number;
     isViewable: boolean;
     item: ItemT;
     key: string;
 }
-interface ViewAmountToken<ItemT = any> extends ViewToken<ItemT> {
+interface ViewAmountToken$1<ItemT = any> extends ViewToken$1<ItemT> {
     percentOfScroller: number;
     percentVisible: number;
     scrollSize: number;
     size: number;
     sizeVisible: number;
 }
-interface ViewabilityConfigCallbackPair<ItemT = any> {
-    onViewableItemsChanged?: OnViewableItemsChanged<ItemT>;
-    viewabilityConfig: ViewabilityConfig;
+interface ViewabilityConfigCallbackPair$1<ItemT = any> {
+    onViewableItemsChanged?: OnViewableItemsChanged$1<ItemT>;
+    viewabilityConfig: ViewabilityConfig$1;
 }
-type ViewabilityConfigCallbackPairs<ItemT> = ViewabilityConfigCallbackPair<ItemT>[];
-type OnViewableItemsChanged<ItemT> = ((info: {
-    viewableItems: Array<ViewToken<ItemT>>;
-    changed: Array<ViewToken<ItemT>>;
+type ViewabilityConfigCallbackPairs$1<ItemT> = ViewabilityConfigCallbackPair$1<ItemT>[];
+type OnViewableItemsChanged$1<ItemT> = ((info: {
+    viewableItems: Array<ViewToken$1<ItemT>>;
+    changed: Array<ViewToken$1<ItemT>>;
 }) => void) | null;
-interface ViewabilityConfig {
+interface ViewabilityConfig$1 {
     /**
      * A unique ID to identify this viewability config
      */
@@ -762,51 +841,354 @@ interface ViewabilityConfig {
      */
     waitForInteraction?: boolean | undefined;
 }
-type ViewabilityCallback<ItemT = any> = (viewToken: ViewToken<ItemT>) => void;
-type ViewabilityAmountCallback<ItemT = any> = (viewToken: ViewAmountToken<ItemT>) => void;
-interface LegendListRecyclingState<T> {
+type ViewabilityCallback$1<ItemT = any> = (viewToken: ViewToken$1<ItemT>) => void;
+type ViewabilityAmountCallback$1<ItemT = any> = (viewToken: ViewAmountToken$1<ItemT>) => void;
+interface LegendListRecyclingState$1<T> {
     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;
-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 TypedForwardRef$1 = <T, P = {}>(render: (props: P, ref: React.Ref<T>) => React.ReactNode) => (props: P & React.RefAttributes<T>) => React.ReactNode;
+declare const typedForwardRef: TypedForwardRef$1;
+type TypedMemo$1 = <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;
-interface ScrollIndexWithOffset {
+declare const typedMemo: TypedMemo$1;
+interface ScrollIndexWithOffset$1 {
     index: number;
     viewOffset?: number;
     viewPosition?: number;
 }
-interface ScrollIndexWithOffsetPosition extends ScrollIndexWithOffset {
+interface ScrollIndexWithOffsetPosition$1 extends ScrollIndexWithOffset$1 {
     viewPosition?: number;
 }
-interface ScrollIndexWithOffsetAndContentOffset extends ScrollIndexWithOffsetPosition {
+interface ScrollIndexWithOffsetAndContentOffset$1 extends ScrollIndexWithOffsetPosition$1 {
     contentOffset?: number;
 }
-interface InitialScrollAnchor extends ScrollIndexWithOffsetPosition {
+interface InitialScrollAnchor$1 extends ScrollIndexWithOffsetPosition$1 {
     attempts?: number;
     lastDelta?: number;
     settledTicks?: number;
 }
-type GetRenderedItemResult<ItemT> = {
+type GetRenderedItemResult$1<ItemT> = {
     index: number;
     item: ItemT;
     renderedItem: React.ReactNode;
 };
-type GetRenderedItem = (key: string) => GetRenderedItemResult<any> | null;
+type GetRenderedItem$1 = (key: string) => GetRenderedItemResult$1<any> | null;
 
-declare const LegendList: (<T>(props: LegendListProps<T> & React$1.RefAttributes<LegendListRef>) => React$1.ReactNode) & {
-    displayName?: string;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type Insets = Insets$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type LayoutRectangle = LayoutRectangle$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type NativeScrollEvent = NativeScrollEvent$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type NativeSyntheticEvent<T> = NativeSyntheticEvent$1<T>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ViewStyle = ViewStyle$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type StyleProp<T> = StyleProp$1<T>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ScrollEventTargetLike = ScrollEventTargetLike$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ScrollableNodeLike = ScrollableNodeLike$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type LegendListScrollerRef = LegendListScrollerRef$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type BaseScrollViewProps<TScrollView> = BaseScrollViewProps$1<TScrollView>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type LegendListPropsBase<ItemT, TScrollViewProps = Record<string, any>, TItemType extends string | undefined = string | undefined> = LegendListPropsBase$1<ItemT, TScrollViewProps, TItemType>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type MaintainVisibleContentPositionConfig<ItemT = any> = MaintainVisibleContentPositionConfig$1<ItemT>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type MaintainVisibleContentPositionNormalized<ItemT = any> = MaintainVisibleContentPositionNormalized$1<ItemT>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type StickyHeaderConfig = StickyHeaderConfig$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type AlwaysRenderConfig = AlwaysRenderConfig$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type MaintainScrollAtEndOptions = MaintainScrollAtEndOptions$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ColumnWrapperStyle = ColumnWrapperStyle$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type LegendListMetrics = LegendListMetrics$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ThresholdSnapshot = ThresholdSnapshot$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ScrollTarget = ScrollTarget$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type InternalState = InternalState$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ViewableRange<T> = ViewableRange$1<T>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type LegendListRenderItemProps<ItemT, TItemType extends string | number | undefined = string | number | undefined> = LegendListRenderItemProps$1<ItemT, TItemType>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type LegendListState = LegendListState$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type LegendListRef = LegendListRef$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ViewToken<ItemT = any> = ViewToken$1<ItemT>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ViewAmountToken<ItemT = any> = ViewAmountToken$1<ItemT>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ViewabilityConfigCallbackPair<ItemT = any> = ViewabilityConfigCallbackPair$1<ItemT>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ViewabilityConfigCallbackPairs<ItemT> = ViewabilityConfigCallbackPairs$1<ItemT>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type OnViewableItemsChanged<ItemT> = OnViewableItemsChanged$1<ItemT>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ViewabilityConfig = ViewabilityConfig$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ViewabilityCallback<ItemT = any> = ViewabilityCallback$1<ItemT>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ViewabilityAmountCallback<ItemT = any> = ViewabilityAmountCallback$1<ItemT>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type LegendListRecyclingState<T> = LegendListRecyclingState$1<T>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type TypedForwardRef = TypedForwardRef$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type TypedMemo = TypedMemo$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ScrollIndexWithOffset = ScrollIndexWithOffset$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ScrollIndexWithOffsetPosition = ScrollIndexWithOffsetPosition$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ScrollIndexWithOffsetAndContentOffset = ScrollIndexWithOffsetAndContentOffset$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type InitialScrollAnchor = InitialScrollAnchor$1;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type GetRenderedItemResult<ItemT> = GetRenderedItemResult$1<ItemT>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type GetRenderedItem = GetRenderedItem$1;
+interface LooseAccessibilityActionEvent {
+    nativeEvent?: {
+        actionName?: string;
+    };
+}
+type AccessibilityActionEvent = LooseAccessibilityActionEvent;
+type LooseAccessibilityRole = string;
+type AccessibilityRole = LooseAccessibilityRole;
+interface LooseAccessibilityState {
+    busy?: boolean;
+    checked?: boolean | "mixed";
+    disabled?: boolean;
+    expanded?: boolean;
+    selected?: boolean;
+}
+type AccessibilityState = LooseAccessibilityState;
+interface LooseAccessibilityValue {
+    max?: number;
+    min?: number;
+    now?: number;
+    text?: string;
+}
+type AccessibilityValue = LooseAccessibilityValue;
+type LooseColorValue = string | number;
+type ColorValue = LooseColorValue;
+interface LooseGestureResponderEvent {
+    nativeEvent?: unknown;
+}
+type GestureResponderEvent = LooseGestureResponderEvent;
+interface LoosePointerEvent {
+    nativeEvent?: unknown;
+}
+type PointerEvent = LoosePointerEvent;
+interface LooseRefreshControlProps {
+    onRefresh?: () => void;
+    progressViewOffset?: number;
+    refreshing?: boolean;
+}
+type RefreshControlProps = LooseRefreshControlProps;
+type LooseRole = string;
+type Role = LooseRole;
+interface PointProp {
+    x: number;
+    y: number;
+}
+interface LayoutChangeEvent {
+    nativeEvent: {
+        layout: LayoutRectangle;
+    };
+}
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+interface LooseScrollViewProps {
+    StickyHeaderComponent?: ComponentType<unknown>;
+    accessibilityActions?: Array<{
+        label?: string;
+        name: string;
+    }>;
+    accessibilityElementsHidden?: boolean;
+    accessibilityHint?: string;
+    accessibilityIgnoresInvertColors?: boolean;
+    accessibilityLabel?: string;
+    accessibilityLabelledBy?: string | string[];
+    accessibilityLanguage?: string;
+    accessibilityLargeContentTitle?: string;
+    accessibilityLiveRegion?: "none" | "polite" | "assertive";
+    accessibilityRespondsToUserInteraction?: boolean;
+    accessibilityRole?: AccessibilityRole;
+    accessibilityShowsLargeContentViewer?: boolean;
+    accessibilityState?: AccessibilityState;
+    accessibilityValue?: AccessibilityValue;
+    accessibilityViewIsModal?: boolean;
+    accessible?: boolean;
+    alwaysBounceHorizontal?: boolean;
+    alwaysBounceVertical?: boolean;
+    "aria-busy"?: boolean;
+    "aria-checked"?: boolean | "mixed";
+    "aria-disabled"?: boolean;
+    "aria-expanded"?: boolean;
+    "aria-hidden"?: boolean;
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    "aria-live"?: "polite" | "assertive" | "off";
+    "aria-modal"?: boolean;
+    "aria-selected"?: boolean;
+    "aria-valuemax"?: number;
+    "aria-valuemin"?: number;
+    "aria-valuenow"?: number;
+    "aria-valuetext"?: string;
+    automaticallyAdjustContentInsets?: boolean;
+    automaticallyAdjustKeyboardInsets?: boolean;
+    automaticallyAdjustsScrollIndicatorInsets?: boolean;
+    bounces?: boolean;
+    bouncesZoom?: boolean;
+    canCancelContentTouches?: boolean;
+    centerContent?: boolean;
+    children?: ReactNode;
+    collapsable?: boolean;
+    collapsableChildren?: boolean;
+    contentContainerStyle?: StyleProp<ViewStyle> | CSSProperties;
+    contentInset?: Insets;
+    contentInsetAdjustmentBehavior?: "always" | "never" | "automatic" | "scrollableAxes";
+    contentOffset?: PointProp;
+    decelerationRate?: number | "fast" | "normal";
+    directionalLockEnabled?: boolean;
+    disableIntervalMomentum?: boolean;
+    disableScrollViewPanResponder?: boolean;
+    endFillColor?: ColorValue;
+    fadingEdgeLength?: number | {
+        end?: number;
+        start?: number;
+    };
+    focusable?: boolean;
+    hasTVPreferredFocus?: boolean;
+    hitSlop?: number | Insets;
+    horizontal?: boolean;
+    id?: string;
+    importantForAccessibility?: "auto" | "yes" | "no" | "no-hide-descendants";
+    indicatorStyle?: "default" | "black" | "white";
+    innerViewRef?: Ref<unknown>;
+    invertStickyHeaders?: boolean;
+    isTVSelectable?: boolean;
+    keyboardDismissMode?: "none" | "interactive" | "on-drag";
+    keyboardShouldPersistTaps?: boolean | "always" | "never" | "handled";
+    maintainVisibleContentPosition?: {
+        autoscrollToTopThreshold?: number;
+        minIndexForVisible: number;
+    };
+    maximumZoomScale?: number;
+    minimumZoomScale?: number;
+    nativeID?: string;
+    needsOffscreenAlphaCompositing?: boolean;
+    nestedScrollEnabled?: boolean;
+    onAccessibilityAction?: (event: AccessibilityActionEvent) => void;
+    onAccessibilityEscape?: () => void;
+    onAccessibilityTap?: () => void;
+    onBlur?: (event: unknown) => void;
+    onContentSizeChange?: (width: number, height: number) => void;
+    onFocus?: (event: unknown) => void;
+    onLayout?: (event: LayoutChangeEvent) => void;
+    onMagicTap?: () => void;
+    onMomentumScrollBegin?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    onMomentumScrollEnd?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    onMoveShouldSetResponder?: (event: GestureResponderEvent) => boolean;
+    onMoveShouldSetResponderCapture?: (event: GestureResponderEvent) => boolean;
+    onPointerCancel?: (event: PointerEvent) => void;
+    onPointerCancelCapture?: (event: PointerEvent) => void;
+    onPointerDown?: (event: PointerEvent) => void;
+    onPointerDownCapture?: (event: PointerEvent) => void;
+    onPointerEnter?: (event: PointerEvent) => void;
+    onPointerEnterCapture?: (event: PointerEvent) => void;
+    onPointerLeave?: (event: PointerEvent) => void;
+    onPointerLeaveCapture?: (event: PointerEvent) => void;
+    onPointerMove?: (event: PointerEvent) => void;
+    onPointerMoveCapture?: (event: PointerEvent) => void;
+    onPointerUp?: (event: PointerEvent) => void;
+    onPointerUpCapture?: (event: PointerEvent) => void;
+    onResponderEnd?: (event: GestureResponderEvent) => void;
+    onResponderGrant?: (event: GestureResponderEvent) => void;
+    onResponderMove?: (event: GestureResponderEvent) => void;
+    onResponderReject?: (event: GestureResponderEvent) => void;
+    onResponderRelease?: (event: GestureResponderEvent) => void;
+    onResponderStart?: (event: GestureResponderEvent) => void;
+    onResponderTerminate?: (event: GestureResponderEvent) => void;
+    onResponderTerminationRequest?: (event: GestureResponderEvent) => boolean;
+    onScroll?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    onScrollAnimationEnd?: () => void;
+    onScrollBeginDrag?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    onScrollEndDrag?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    onScrollToTop?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    onStartShouldSetResponder?: (event: GestureResponderEvent) => boolean;
+    onStartShouldSetResponderCapture?: (event: GestureResponderEvent) => boolean;
+    onTouchCancel?: (event: GestureResponderEvent) => void;
+    onTouchEnd?: (event: GestureResponderEvent) => void;
+    onTouchEndCapture?: (event: GestureResponderEvent) => void;
+    onTouchMove?: (event: GestureResponderEvent) => void;
+    onTouchStart?: (event: GestureResponderEvent) => void;
+    overScrollMode?: "always" | "never" | "auto";
+    pagingEnabled?: boolean;
+    persistentScrollbar?: boolean;
+    pinchGestureEnabled?: boolean;
+    pointerEvents?: "none" | "box-none" | "box-only" | "auto";
+    refreshControl?: ReactElement<RefreshControlProps, string | JSXElementConstructor<unknown>>;
+    removeClippedSubviews?: boolean;
+    renderToHardwareTextureAndroid?: boolean;
+    role?: Role;
+    screenReaderFocusable?: boolean;
+    scrollEnabled?: boolean;
+    scrollEventThrottle?: number;
+    scrollIndicatorInsets?: Insets;
+    scrollPerfTag?: string;
+    scrollToOverflowEnabled?: boolean;
+    scrollViewRef?: Ref<unknown>;
+    scrollsToTop?: boolean;
+    shouldRasterizeIOS?: boolean;
+    showsHorizontalScrollIndicator?: boolean;
+    showsVerticalScrollIndicator?: boolean;
+    snapToAlignment?: "start" | "center" | "end";
+    snapToEnd?: boolean;
+    snapToInterval?: number;
+    snapToOffsets?: number[];
+    snapToStart?: boolean;
+    stickyHeaderHiddenOnScroll?: boolean;
+    stickyHeaderIndices?: number[];
+    style?: StyleProp<ViewStyle> | CSSProperties;
+    tabIndex?: 0 | -1;
+    testID?: string;
+    tvParallaxMagnification?: number;
+    tvParallaxShiftDistanceX?: number;
+    tvParallaxShiftDistanceY?: number;
+    tvParallaxTiltAngle?: number;
+    zoomScale?: number;
+}
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type ScrollViewPropsLoose = LooseScrollViewProps;
+type LegendListPropsLoose<ItemT = any> = Omit<LegendListPropsBase<ItemT, LooseScrollViewProps>, "ListHeaderComponentStyle" | "ListFooterComponentStyle"> & {
+    ListHeaderComponentStyle?: StyleProp<ViewStyle> | CSSProperties | undefined;
+    ListFooterComponentStyle?: StyleProp<ViewStyle> | CSSProperties | undefined;
 };
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+type LegendListProps<ItemT = any> = LegendListPropsLoose<ItemT>;
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+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 useViewability<ItemT = any>(callback: ViewabilityCallback$1<ItemT>, configId?: string): void;
+declare function useViewabilityAmount<ItemT = any>(callback: ViewabilityAmountCallback$1<ItemT>): void;
+declare function useRecyclingEffect(effect: (info: LegendListRecyclingState$1<unknown>) => void | (() => void)): void;
+declare function useRecyclingState<ItemT>(valueOrFun: ((info: LegendListRecyclingState$1<ItemT>) => ItemT) | ItemT): readonly [ItemT, Dispatch<SetStateAction<ItemT>>];
 declare function useIsLastItem(): boolean;
 declare function useListScrollSize(): {
     width: number;
@@ -814,4 +1196,7 @@ declare function useListScrollSize(): {
 };
 declare function useSyncLayout(): () => void;
 
-export { type AlwaysRenderConfig, type ColumnWrapperStyle, type GetRenderedItem, type GetRenderedItemResult, type InitialScrollAnchor, type InternalState, LegendList, type LegendListMetrics, type LegendListProps, type LegendListPropsBase, type LegendListRecyclingState, type LegendListRef, type LegendListRenderItemProps, type LegendListState, type MaintainScrollAtEndOptions, type MaintainVisibleContentPositionConfig, type MaintainVisibleContentPositionNormalized, type OnViewableItemsChanged, type ScrollIndexWithOffset, type ScrollIndexWithOffsetAndContentOffset, type ScrollIndexWithOffsetPosition, type ScrollTarget, type StickyHeaderConfig, type ThresholdSnapshot, type TypedForwardRef, type TypedMemo, type ViewAmountToken, type ViewToken, type ViewabilityAmountCallback, type ViewabilityCallback, type ViewabilityConfig, type ViewabilityConfigCallbackPair, type ViewabilityConfigCallbackPairs, type ViewableRange, typedForwardRef, typedMemo, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };
+/** @deprecated Use `@legendapp/list/react-native` or `@legendapp/list/react` for strict typing */
+declare const LegendList: LegendListComponent;
+
+export { type AccessibilityActionEvent, type AccessibilityRole, type AccessibilityState, type AccessibilityValue, type AlwaysRenderConfig, type BaseScrollViewProps, type ColorValue, type ColumnWrapperStyle, type GestureResponderEvent, type GetRenderedItem, type GetRenderedItemResult, type InitialScrollAnchor, type Insets, type InternalState, type LayoutChangeEvent, type LayoutRectangle, LegendList, type LegendListComponent, type LegendListMetrics, type LegendListProps, type LegendListPropsBase, type LegendListRecyclingState, type LegendListRef, type LegendListRenderItemProps, type LegendListScrollerRef, type LegendListState, type LooseAccessibilityActionEvent, type LooseAccessibilityRole, type LooseAccessibilityState, type LooseAccessibilityValue, type LooseColorValue, type LooseGestureResponderEvent, type LoosePointerEvent, type LooseRefreshControlProps, type LooseRole, type LooseScrollViewProps, type MaintainScrollAtEndOptions, type MaintainVisibleContentPositionConfig, type MaintainVisibleContentPositionNormalized, type NativeScrollEvent, type NativeSyntheticEvent, type OnViewableItemsChanged, type PointProp, type PointerEvent, type RefreshControlProps, type Role, type ScrollEventTargetLike, type ScrollIndexWithOffset, type ScrollIndexWithOffsetAndContentOffset, type ScrollIndexWithOffsetPosition, type ScrollTarget, type ScrollViewPropsLoose, 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 };