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

package/{list-react.d.ts → react.d.ts}

@@ -1,19 +1,25 @@
 import * as React$1 from 'react';
-import { Key, ReactNode, ComponentType, CSSProperties, Ref, ReactElement, JSXElementConstructor, HTMLAttributes, RefAttributes, Dispatch, SetStateAction } from 'react';
+import { Key, ReactNode, ReactElement, HTMLAttributes, CSSProperties, Ref, RefAttributes, Dispatch, SetStateAction } from 'react';
+
+type ScrollEventTarget = Window | HTMLElement;
 
 interface ScrollViewMethods {
-    scrollBy(x: number, y: number): void;
     getBoundingClientRect(): DOMRect | null | undefined;
-    scrollToEnd(options?: {
-        animated?: boolean;
-    }): void;
+    getContentNode(): HTMLElement | null;
+    getCurrentScrollOffset(): number;
+    getScrollableNode(): HTMLElement;
+    getScrollEventTarget(): ScrollEventTarget | null;
     getScrollResponder(): HTMLElement | null;
-    getScrollableNode(): HTMLDivElement;
+    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;
@@ -22,11 +28,6 @@ interface ScrollViewMethods {
 
 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 = {
@@ -107,19 +108,19 @@ type StylesAsSharedValue<Style> = {
     [key in keyof Style]: Style[key] | BaseSharedValue<Style[key]>;
 };
 
-interface Insets$1 {
+interface Insets {
     top: number;
     left: number;
     bottom: number;
     right: number;
 }
-interface LayoutRectangle$1 {
+interface LayoutRectangle {
     x: number;
     y: number;
     width: number;
     height: number;
 }
-interface NativeScrollEvent$1 {
+interface NativeScrollEvent {
     contentOffset: {
         x: number;
         y: number;
@@ -132,14 +133,37 @@ interface NativeScrollEvent$1 {
         width: number;
         height: number;
     };
-    contentInset: Insets$1;
+    contentInset: Insets;
     zoomScale: number;
 }
-interface NativeSyntheticEvent$1<T> {
+interface NativeSyntheticEvent<T> {
     nativeEvent: T;
 }
-type ViewStyle$1 = Record<string, unknown>;
-type StyleProp$1<T> = T | T[] | null | undefined | false;
+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> {
     /**
@@ -268,7 +292,7 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
     /**
      * Style for the footer component.
      */
-    ListFooterComponentStyle?: StyleProp$1<ViewStyle$1> | undefined;
+    ListFooterComponentStyle?: StyleProp<ViewStyle> | undefined;
     /**
      * Component or element to render above the list.
      */
@@ -276,7 +300,7 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
     /**
      * Style for the header component.
      */
-    ListHeaderComponentStyle?: StyleProp$1<ViewStyle$1> | undefined;
+    ListHeaderComponentStyle?: StyleProp<ViewStyle> | undefined;
     /**
      * If true, auto-scrolls to end when new items are added.
      * @default false
@@ -296,6 +320,11 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * - 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
+     */
+    useWindowScroll?: boolean;
     /**
      * Number of columns to render items in.
      * @default 1
@@ -330,7 +359,7 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Function to call when the user pulls to refresh.
      */
     onRefresh?: () => void;
-    onScroll?: (event: NativeSyntheticEvent$1<NativeScrollEvent$1>) => void;
+    onScroll?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
     /**
      * Called when scrolling reaches the start within onStartReachedThreshold.
      */
@@ -490,10 +519,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;
@@ -522,7 +552,7 @@ interface InternalState {
     isFirst?: boolean;
     isStartReached: boolean | null;
     lastBatchingAction: number;
-    lastLayout: LayoutRectangle$1 | undefined;
+    lastLayout: LayoutRectangle | undefined;
     lastScrollAdjustForHistory?: number;
     lastScrollDelta: number;
     loadStartTime: number;
@@ -534,18 +564,19 @@ interface InternalState {
         quietPasses: number;
         expiresAt: number;
     };
-    contentInsetOverride?: Partial<Insets$1> | null;
-    nativeContentInset?: Insets$1;
+    contentInsetOverride?: Partial<Insets> | null;
+    nativeContentInset?: Insets;
     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<any>;
+    refScroller: React.RefObject<LegendListScrollerRef | null>;
     scroll: number;
     scrollAdjustHandler: ScrollAdjustHandler;
     scrollForNextCalculateItemsInView: {
@@ -569,6 +600,7 @@ interface InternalState {
     startBuffered: number;
     startBufferedId?: string;
     startNoBuffer: number;
+    startReachedSnapshotDataChangeEpoch: number | undefined;
     startReachedSnapshot: ThresholdSnapshot | undefined;
     stickyContainerPool: Set<number>;
     stickyContainers: Map<number, number>;
@@ -589,7 +621,7 @@ interface InternalState {
         alwaysRender: AlwaysRenderConfig | undefined;
         alwaysRenderIndicesArr: number[];
         alwaysRenderIndicesSet: Set<number>;
-        contentInset: Insets$1 | undefined;
+        contentInset: Insets | undefined;
         data: readonly any[];
         dataVersion: Key | undefined;
         drawDistance: number;
@@ -618,12 +650,14 @@ interface InternalState {
         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> {
@@ -652,7 +686,7 @@ type LegendListState$1 = {
     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;
@@ -691,7 +725,7 @@ type LegendListRef$1 = {
     scrollIndexIntoView(params: {
         animated?: boolean | undefined;
         index: number;
-    }): void;
+    }): Promise<void>;
     /**
      * Scrolls a specific index into view.
      * @param params - Parameters for scrolling.
@@ -701,7 +735,7 @@ type LegendListRef$1 = {
     scrollItemIntoView(params: {
         animated?: boolean | undefined;
         item: any;
-    }): void;
+    }): Promise<void>;
     /**
      * Scrolls to the end of the list.
      * @param options - Options for scrolling.
@@ -711,7 +745,7 @@ type LegendListRef$1 = {
     scrollToEnd(options?: {
         animated?: boolean | undefined;
         viewOffset?: number | undefined;
-    }): void;
+    }): Promise<void>;
     /**
      * Scrolls to a specific index in the list.
      * @param params - Parameters for scrolling.
@@ -725,7 +759,7 @@ type LegendListRef$1 = {
         index: number;
         viewOffset?: number | undefined;
         viewPosition?: number | undefined;
-    }): void;
+    }): Promise<void>;
     /**
      * Scrolls to a specific item in the list.
      * @param params - Parameters for scrolling.
@@ -739,7 +773,7 @@ type LegendListRef$1 = {
         item: any;
         viewOffset?: number | undefined;
         viewPosition?: number | undefined;
-    }): void;
+    }): Promise<void>;
     /**
      * Scrolls to a specific offset in pixels.
      * @param params - Parameters for scrolling.
@@ -749,7 +783,7 @@ type LegendListRef$1 = {
     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.
@@ -773,7 +807,7 @@ type LegendListRef$1 = {
      * 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$1> | null): void;
+    reportContentInset(inset?: Partial<Insets> | null): void;
 };
 interface ViewToken<ItemT = any> {
     containerId: number;
@@ -864,244 +898,48 @@ type GetRenderedItemResult<ItemT> = {
 };
 type GetRenderedItem = (key: string) => GetRenderedItemResult<any> | null;
 
-/** @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 {
+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;
 }
-/** @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;
+    contentContainerStyle?: StyleProp<ViewStyle>;
     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;
+    contentOffset?: {
+        x: number;
+        y: 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;
+    onLayout?: (event: LooseLayoutChangeEvent) => 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>>;
+    refreshControl?: ReactElement | null;
     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;
+    style?: StyleProp<ViewStyle>;
 }
 
-type ScrollViewPropsWeb = Omit<LooseScrollViewProps, "style" | "contentContainerStyle" | "onScroll" | "onLayout"> & HTMLAttributes<HTMLElement> & {
+type ScrollViewPropsWeb = Omit<LooseScrollViewProps, "style" | "contentContainerStyle" | "onScroll" | "onLayout" | "pagingEnabled" | "snapToInterval"> & Omit<HTMLAttributes<HTMLDivElement>, "onScroll" | "onLayout" | "style"> & {
     style?: CSSProperties;
     contentContainerStyle?: CSSProperties;
-    onScroll?: (event: NativeSyntheticEvent$1<NativeScrollEvent$1>) => void;
-    onLayout?: (event: {
-        nativeEvent: {
-            layout: LayoutRectangle$1;
-        };
-    }) => void;
+    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>;
-    renderScrollComponent?: (props: ScrollViewPropsWeb) => ReactElement<ScrollViewPropsWeb> | null;
     ListHeaderComponentStyle?: CSSProperties | undefined;
     ListFooterComponentStyle?: CSSProperties | undefined;
 };
@@ -1129,4 +967,4 @@ declare function useSyncLayout(): () => void;
 
 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 };
+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 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 };