@legendapp/list 3.0.0-beta.31 → 3.0.0-beta.33

package/{index.native.d.mts → list-react.d.ts}

@@ -1,10 +1,32 @@
 import * as React$1 from 'react';
-import { ComponentProps, Key, ReactNode, Dispatch, SetStateAction } from 'react';
-import { View, ScrollView, Animated, LayoutRectangle, Insets, ScrollViewProps, ScrollViewComponent, ScrollResponderMixin, StyleProp, ViewStyle, NativeSyntheticEvent, NativeScrollEvent } from 'react-native';
-import Reanimated from 'react-native-reanimated';
+import { Key, ReactNode, ComponentType, CSSProperties, Ref, ReactElement, JSXElementConstructor, HTMLAttributes, RefAttributes, Dispatch, SetStateAction } from 'react';
+
+interface ScrollViewMethods {
+    scrollBy(x: number, y: number): void;
+    getBoundingClientRect(): DOMRect | null | undefined;
+    scrollToEnd(options?: {
+        animated?: boolean;
+    }): void;
+    getScrollResponder(): HTMLElement | null;
+    getScrollableNode(): HTMLDivElement;
+    scrollTo(options: {
+        x?: number;
+        y?: number;
+        animated?: boolean;
+    }): void;
+    scrollToOffset(params: {
+        offset: number;
+        animated?: boolean;
+    }): void;
+}
 
 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 = {
@@ -65,7 +87,7 @@ interface StateContext {
     positionListeners: Map<string, Set<(value: any) => void>>;
     state: InternalState;
     values: Map<ListenerType, any>;
-    viewRefs: Map<number, React$1.RefObject<View>>;
+    viewRefs: Map<number, React$1.RefObject<LooseView>>;
 }
 
 declare class ScrollAdjustHandler {
@@ -85,6 +107,39 @@ type StylesAsSharedValue<Style> = {
     [key in keyof Style]: Style[key] | BaseSharedValue<Style[key]>;
 };
 
+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;
 type BaseScrollViewProps<TScrollView> = Omit<TScrollView, "contentOffset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children" | "onScroll">;
 interface DataModeProps<ItemT, TItemType extends string | undefined> {
     /**
@@ -213,7 +268,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,7 +276,7 @@ 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
@@ -275,7 +330,7 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * 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.
      */
@@ -311,7 +366,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 +377,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
@@ -366,7 +421,8 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | 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;
@@ -410,7 +466,6 @@ interface LegendListMetrics {
     headerSize: number;
     footerSize: number;
 }
-type LegendListProps<ItemT = any> = LegendListPropsBase<ItemT, ComponentProps<typeof ScrollView>>;
 interface ThresholdSnapshot {
     scrollPosition: number;
     contentSize?: number;
@@ -467,14 +522,20 @@ interface InternalState {
     isFirst?: boolean;
     isStartReached: boolean | null;
     lastBatchingAction: number;
-    lastLayout: LayoutRectangle | undefined;
+    lastLayout: LayoutRectangle$1 | undefined;
     lastScrollAdjustForHistory?: number;
     lastScrollDelta: number;
     loadStartTime: number;
     maintainingScrollAtEnd?: boolean;
     minIndexSizeChanged: number | undefined;
-    contentInsetOverride?: Partial<Insets> | null;
-    nativeContentInset?: Insets;
+    mvcpAnchorLock?: {
+        id: string;
+        position: number;
+        quietPasses: number;
+        expiresAt: number;
+    };
+    contentInsetOverride?: Partial<Insets$1> | null;
+    nativeContentInset?: Insets$1;
     nativeMarginTop: number;
     needsOtherAxisSize?: boolean;
     otherAxisSize?: number;
@@ -482,8 +543,9 @@ interface InternalState {
     positions: Map<string, number>;
     previousData?: readonly unknown[];
     queuedCalculateItemsInView: number | undefined;
+    queuedMVCPRecalculate?: number;
     queuedInitialLayout?: boolean | undefined;
-    refScroller: React.RefObject<ScrollView>;
+    refScroller: React.RefObject<any>;
     scroll: number;
     scrollAdjustHandler: ScrollAdjustHandler;
     scrollForNextCalculateItemsInView: {
@@ -523,38 +585,40 @@ interface InternalState {
     viewabilityConfigCallbackPairs: ViewabilityConfigCallbackPairs<any> | undefined;
     props: {
         alignItemsAtEnd: boolean;
-        animatedProps: StylesAsSharedValue<ScrollViewProps>;
+        animatedProps: StylesAsSharedValue<Record<string, any>>;
         alwaysRender: AlwaysRenderConfig | 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"];
+        itemsAreEqual: LegendListPropsInternal["itemsAreEqual"];
+        keyExtractor: LegendListPropsInternal["keyExtractor"];
         maintainScrollAtEnd: boolean | MaintainScrollAtEndOptions;
         maintainScrollAtEndThreshold: number | undefined;
         maintainVisibleContentPosition: MaintainVisibleContentPositionNormalized;
         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"];
-        scrollBuffer: number;
+        renderItem: LegendListPropsInternal["renderItem"];
+        scrollBuffer?: number;
         snapToIndices: number[] | undefined;
+        stickyPositionComponentInternal: React.ComponentType<any> | undefined;
         stickyIndicesArr: number[];
         stickyIndicesSet: Set<number>;
         stylePaddingBottom: number | undefined;
@@ -576,11 +640,11 @@ interface LegendListRenderItemProps<ItemT, TItemType extends string | number | u
     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;
@@ -597,7 +661,7 @@ type LegendListState = {
     start: number;
     startBuffered: number;
 };
-type LegendListRef = {
+type LegendListRef$1 = {
     /**
      * Displays the scroll indicators momentarily.
      */
@@ -605,7 +669,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.
      */
@@ -613,11 +677,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.
@@ -697,11 +761,19 @@ 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> {
     containerId: number;
@@ -792,9 +864,257 @@ type GetRenderedItemResult<ItemT> = {
 };
 type GetRenderedItem = (key: string) => GetRenderedItemResult<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>;
+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;
+}
+
+type ScrollViewPropsWeb = Omit<LooseScrollViewProps, "style" | "contentContainerStyle" | "onScroll" | "onLayout"> & HTMLAttributes<HTMLElement> & {
+    style?: CSSProperties;
+    contentContainerStyle?: CSSProperties;
+    onScroll?: (event: NativeSyntheticEvent$1<NativeScrollEvent$1>) => void;
+    onLayout?: (event: {
+        nativeEvent: {
+            layout: LayoutRectangle$1;
+        };
+    }) => void;
+};
+type LegendListPropsOverrides<ItemT, TItemType extends string | undefined> = Omit<LegendListPropsBase<ItemT, ScrollViewPropsWeb, TItemType>, "refScrollView" | "renderScrollComponent" | "ListHeaderComponentStyle" | "ListFooterComponentStyle"> & {
+    refScrollView?: Ref<HTMLElement | ScrollViewMethods>;
+    renderScrollComponent?: (props: ScrollViewPropsWeb) => ReactElement<ScrollViewPropsWeb> | null;
+    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;
@@ -807,4 +1127,6 @@ 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 };
+declare const LegendList: LegendListComponent;
+
+export { type AlwaysRenderConfig, type BaseScrollViewProps, type ColumnWrapperStyle, type GetRenderedItem, type GetRenderedItemResult, type InitialScrollAnchor, type Insets$1 as Insets, type InternalState, type LayoutRectangle$1 as LayoutRectangle, LegendList, type LegendListComponent, type LegendListMetrics, type LegendListProps, type LegendListPropsBase, type LegendListRecyclingState, type LegendListRef, type LegendListRenderItemProps, type LegendListState, type MaintainScrollAtEndOptions, type MaintainVisibleContentPositionConfig, type MaintainVisibleContentPositionNormalized, type NativeScrollEvent$1 as NativeScrollEvent, type NativeSyntheticEvent$1 as NativeSyntheticEvent, type OnViewableItemsChanged, type ScrollIndexWithOffset, type ScrollIndexWithOffsetAndContentOffset, type ScrollIndexWithOffsetPosition, type ScrollTarget, type StickyHeaderConfig, type StyleProp$1 as StyleProp, type ThresholdSnapshot, type TypedForwardRef, type TypedMemo, type ViewAmountToken, type ViewStyle$1 as ViewStyle, type ViewToken, type ViewabilityAmountCallback, type ViewabilityCallback, type ViewabilityConfig, type ViewabilityConfigCallbackPair, type ViewabilityConfigCallbackPairs, type ViewableRange, typedForwardRef, typedMemo, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };