@depup/react-native 0.86.2-depup.0 → 0.87.1-depup.0

package/types_generated/Libraries/Components/ScrollView/ScrollView.d.ts

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<907a729d1a63e978acf9a2a2d9065180>>
+ * @generated SignedSource<<3220e238eadca54ae7f57c65cefff83f>>
  *
  * This file was translated from Flow by scripts/js-api/build-types/index.js.
  * Original file: packages/react-native/Libraries/Components/ScrollView/ScrollView.js
@@ -23,63 +23,104 @@ import View from "../View/View";
 import ScrollViewContext from "./ScrollViewContext";
 import * as React from "react";
 export interface ScrollViewScrollToOptions {
-  x?: number;
-  y?: number;
-  animated?: boolean;
+  x?: number | undefined;
+  y?: number | undefined;
+  animated?: boolean | undefined;
 }
 export interface ScrollViewImperativeMethods {
+  /**
+   * Returns a reference to the underlying scroll responder, which supports
+   * operations like `scrollTo`. All ScrollView-like components should
+   * implement this method so that they can be composed while providing access
+   * to the underlying scroll responder's methods.
+   */
   readonly getScrollResponder: () => ScrollResponderType;
   readonly getScrollableNode: () => number | undefined;
   readonly getInnerViewNode: () => number | undefined;
   readonly getInnerViewRef: () => InnerViewInstance | null;
-  readonly getNativeScrollRef: () => HostInstance | null;
+  /**
+   * Returns a reference to the underlying native scroll view, or null if the
+   * native instance is not mounted.
+   */
+  readonly getNativeScrollRef: () => ScrollViewInstance | null;
+  /**
+   * Scrolls to a given x, y offset, either immediately or with a smooth animation.
+   * Syntax:
+   *
+   * scrollTo(options: {x: number = 0; y: number = 0; animated: boolean = true})
+   *
+   * Note: The weird argument signature is due to the fact that, for historical reasons,
+   * the function also accepts separate arguments as an alternative to the options object.
+   * This is deprecated due to ambiguity (y before x), and SHOULD NOT BE USED.
+   */
   readonly scrollTo: (options?: ScrollViewScrollToOptions | number, deprecatedX?: number, deprecatedAnimated?: boolean) => void;
+  /**
+   * A helper function that scrolls to the end of the scrollview;
+   * If this is a vertical ScrollView, it scrolls to the bottom.
+   * If this is a horizontal ScrollView scrolls to the right.
+   *
+   * The options object has an animated prop, that enables the scrolling animation or not.
+   * The animated prop defaults to true
+   */
   readonly scrollToEnd: (options?: ScrollViewScrollToOptions | undefined) => void;
+  /**
+   * Displays the scroll indicators momentarily.
+   */
   readonly flashScrollIndicators: () => void;
   readonly scrollResponderZoomTo: (rect: {
     x: number;
     y: number;
     width: number;
     height: number;
-    animated?: boolean;
+    animated?: boolean | undefined;
   }, animated?: boolean) => void;
   readonly scrollResponderScrollNativeHandleToKeyboard: (nodeHandle: number | HostInstance, additionalOffset?: number, preventNegativeScrollOffset?: boolean) => void;
 }
 export type DecelerationRateType = "fast" | "normal" | number;
 export type ScrollResponderType = ScrollViewImperativeMethods;
-export interface PublicScrollViewInstance extends HostInstance, ScrollViewImperativeMethods {}
+export interface ScrollViewInstance extends HostInstance, ScrollViewImperativeMethods {}
 type InnerViewInstance = React.ComponentRef<typeof View>;
 export type ScrollViewPropsIOS = Readonly<{
   /**
    * Controls whether iOS should automatically adjust the content inset
    * for scroll views that are placed behind a navigation bar or
-   * tab bar/ toolbar. The default value is true.
+   * tab bar/toolbar.
+   *
+   * @default `true`
    * @platform ios
    */
   automaticallyAdjustContentInsets?: boolean | undefined;
   /**
    * Controls whether the ScrollView should automatically adjust its `contentInset`
-   * and `scrollViewInsets` when the Keyboard changes its size. The default value is false.
+   * and `scrollViewInsets` when the Keyboard changes its size.
+   *
+   * @default `false`
    * @platform ios
    */
   automaticallyAdjustKeyboardInsets?: boolean | undefined;
   /**
    * Controls whether iOS should automatically adjust the scroll indicator
-   * insets. The default value is true. Available on iOS 13 and later.
+   * insets. Available on iOS 13 and later.
+   *
+   * @default `true`
    * @platform ios
    */
   automaticallyAdjustsScrollIndicatorInsets?: boolean | undefined;
   /**
    * The amount by which the scroll view content is inset from the edges
-   * of the scroll view. Defaults to `{top: 0, left: 0, bottom: 0, right: 0}`.
+   * of the scroll view.
+   *
+   * @default `{top: 0, left: 0, bottom: 0, right: 0}`
    * @platform ios
    */
   contentInset?: EdgeInsetsProp | undefined;
   /**
    * When true, the scroll view bounces when it reaches the end of the
-   * content if the content is larger then the scroll view along the axis of
-   * the scroll direction. When false, it disables all bouncing even if
-   * the `alwaysBounce*` props are true. The default value is true.
+   * content if the content is larger than the scroll view along the axis of
+   * the scroll direction. When `false`, it disables all bouncing even if
+   * the `alwaysBounce*` props are `true`.
+   *
+   * @default `true`
    * @platform ios
    */
   bounces?: boolean | undefined;
@@ -99,23 +140,26 @@ export type ScrollViewPropsIOS = Readonly<{
   bouncesZoom?: boolean | undefined;
   /**
    * When true, the scroll view bounces horizontally when it reaches the end
-   * even if the content is smaller than the scroll view itself. The default
-   * value is true when `horizontal={true}` and false otherwise.
+   * even if the content is smaller than the scroll view itself.
+   *
+   * @default {@platform horizontal} `true`
    * @platform ios
    */
   alwaysBounceHorizontal?: boolean | undefined;
   /**
    * When true, the scroll view bounces vertically when it reaches the end
-   * even if the content is smaller than the scroll view itself. The default
-   * value is false when `horizontal={true}` and true otherwise.
+   * even if the content is smaller than the scroll view itself.
+   *
+   * @default {@platform horizontal} `false`
    * @platform ios
    */
   alwaysBounceVertical?: boolean | undefined;
   /**
    * When true, the scroll view automatically centers the content when the
    * content is smaller than the scroll view bounds; when the content is
-   * larger than the scroll view, this property has no effect. The default
-   * value is false.
+   * larger than the scroll view, this property has no effect.
+   *
+   * @default `false`
    * @platform ios
    */
   centerContent?: boolean | undefined;
@@ -131,48 +175,62 @@ export type ScrollViewPropsIOS = Readonly<{
   indicatorStyle?: ("default" | "black" | "white") | undefined;
   /**
    * When true, the ScrollView will try to lock to only vertical or horizontal
-   * scrolling while dragging.  The default value is false.
+   * scrolling while dragging.
+   *
+   * @default `false`
    * @platform ios
    */
   directionalLockEnabled?: boolean | undefined;
   /**
-   * When false, once tracking starts, won't try to drag if the touch moves.
-   * The default value is true.
+   * When false, once tracking starts, the scroll view will not try to drag
+   * if the touch moves.
+   *
+   * @default `true`
    * @platform ios
    */
   canCancelContentTouches?: boolean | undefined;
   /**
-   * The maximum allowed zoom scale. The default value is 1.0.
+   * The maximum allowed zoom scale.
+   *
+   * @default `1.0`
    * @platform ios
    */
   maximumZoomScale?: number | undefined;
   /**
-   * The minimum allowed zoom scale. The default value is 1.0.
+   * The minimum allowed zoom scale.
+   *
+   * @default `1.0`
    * @platform ios
    */
   minimumZoomScale?: number | undefined;
   /**
    * When true, ScrollView allows use of pinch gestures to zoom in and out.
-   * The default value is true.
+   *
+   * @default `true`
    * @platform ios
    */
   pinchGestureEnabled?: boolean | undefined;
   /**
    * The amount by which the scroll view indicators are inset from the edges
    * of the scroll view. This should normally be set to the same value as
-   * the `contentInset`. Defaults to `{0, 0, 0, 0}`.
+   * the `contentInset`.
+   *
+   * @default `{top: 0, left: 0, bottom: 0, right: 0}`
    * @platform ios
    */
   scrollIndicatorInsets?: EdgeInsetsProp | undefined;
   /**
    * When true, the scroll view can be programmatically scrolled beyond its
-   * content size. The default value is false.
+   * content size.
+   *
+   * @default `false`
    * @platform ios
    */
   scrollToOverflowEnabled?: boolean | undefined;
   /**
    * When true, the scroll view scrolls to top when the status bar is tapped.
-   * The default value is true.
+   *
+   * @default `true`
    * @platform ios
    */
   scrollsToTop?: boolean | undefined;
@@ -180,29 +238,35 @@ export type ScrollViewPropsIOS = Readonly<{
    * Fires when the scroll view scrolls to top after the status bar has been tapped
    * @platform ios
    */
-  onScrollToTop?: (event: ScrollEvent) => void;
+  onScrollToTop?: ((event: ScrollEvent) => void) | undefined;
   /**
    * When true, shows a horizontal scroll indicator.
-   * The default value is true.
+   *
+   * @default `true`
    */
   showsHorizontalScrollIndicator?: boolean | undefined;
   /**
-   * The current scale of the scroll view content. The default value is 1.0.
+   * The current scale of the scroll view content.
+   *
+   * @default `1.0`
    * @platform ios
    */
   zoomScale?: number | undefined;
   /**
    * This property specifies how the safe area insets are used to modify the
-   * content area of the scroll view. The default value of this property is
-   * "never".
+   * content area of the scroll view.
+   *
+   * @default `'never'`
    * @platform ios
    */
   contentInsetAdjustmentBehavior?: ("automatic" | "scrollableAxes" | "never" | "always") | undefined;
 }>;
 export type ScrollViewPropsAndroid = Readonly<{
   /**
-   * Enables nested scrolling for Android API level 21+.
-   * Nested scrolling is supported by default on iOS
+   * Enables nested scrolling for Android API level 21+. Nested scrolling is
+   * supported by default on iOS.
+   *
+   * @default `false`
    * @platform android
    */
   nestedScrollEnabled?: boolean | undefined;
@@ -237,8 +301,8 @@ export type ScrollViewPropsAndroid = Readonly<{
   overScrollMode?: ("auto" | "always" | "never") | undefined;
   /**
    * Causes the scrollbars not to turn transparent when they are not in use.
-   * The default value is false.
    *
+   * @default `false`
    * @platform android
    */
   persistentScrollbar?: boolean | undefined;
@@ -259,12 +323,13 @@ export type ScrollViewPropsAndroid = Readonly<{
   fadingEdgeLength?: (number | undefined) | {
     start: number;
     end: number;
-  };
+  } | undefined;
   /**
    * When false, the ScrollView will not automatically scroll to a focused child when
    * the child requests focus. This can be useful when you want to control the scroll
-   * position programmatically. The default value is true.
+   * position programmatically.
    *
+   * @default `true`
    * @platform android
    */
   scrollsChildToFocus?: boolean | undefined;
@@ -272,18 +337,20 @@ export type ScrollViewPropsAndroid = Readonly<{
 type StickyHeaderComponentType = (props: Omit<ScrollViewStickyHeaderProps, keyof {
   ref?: React.Ref<Readonly<{
     setNextHeaderY: ($$PARAM_0$$: number) => void;
-  }>>;
+  }>> | undefined;
 }> & {
   ref?: React.Ref<Readonly<{
     setNextHeaderY: ($$PARAM_0$$: number) => void;
-  }>>;
+  }>> | undefined;
 }) => React.ReactNode;
 type ScrollViewBaseProps = Readonly<{
   /**
    * These styles will be applied to the scroll view content container which
-   * wraps all of the child views. Example:
+   * wraps all of the child views.
    *
-   * ```
+   * Example:
+   *
+   * ```tsx
    * return (
    *   <ScrollView contentContainerStyle={styles.contentContainer}>
    *   </ScrollView>
@@ -299,14 +366,17 @@ type ScrollViewBaseProps = Readonly<{
   contentContainerStyle?: ViewStyleProp | undefined;
   /**
    * Used to manually set the starting scroll offset.
-   * The default value is `{x: 0, y: 0}`.
+   *
+   * @default `{x: 0, y: 0}`
    */
   contentOffset?: PointProp | undefined;
   /**
    * When true, the scroll view stops on the next index (in relation to scroll
    * position at release) regardless of how fast the gesture is. This can be
    * used for pagination when the page is less than the width of the
-   * horizontal ScrollView or the height of the vertical ScrollView. The default value is false.
+   * horizontal ScrollView or the height of the vertical ScrollView.
+   *
+   * @default `false`
    */
   disableIntervalMomentum?: boolean | undefined;
   /**
@@ -316,25 +386,29 @@ type ScrollViewBaseProps = Readonly<{
    * for `UIScrollViewDecelerationRateNormal` and
    * `UIScrollViewDecelerationRateFast` respectively.
    *
-   *   - `'normal'`: 0.998 on iOS, 0.985 on Android (the default)
+   *   - `'normal'`: 0.998 on iOS, 0.985 on Android
    *   - `'fast'`: 0.99 on iOS, 0.9 on Android
+   *
+   * @default `'normal'`
    */
   decelerationRate?: DecelerationRateType | undefined;
   /**
    * *Experimental, iOS Only*. The API is experimental and will change in future releases.
    *
-   * Controls how much distance is travelled after user stops scrolling.
-   * Value greater than 1 will increase the distance travelled.
-   * Value less than 1 will decrease the distance travelled.
+   * Controls how much distance is traveled after user stops scrolling.
+   * A value greater than 1 will increase the distance traveled.
+   * A value less than 1 will decrease the distance traveled.
    *
    * @deprecated
    *
-   * The default value is 1.
+   * @default `1`
    */
   experimental_endDraggingSensitivityMultiplier?: number | undefined;
   /**
    * When true, the scroll view's children are arranged horizontally in a row
-   * instead of vertically in a column. The default value is false.
+   * instead of vertically in a column.
+   *
+   * @default `false`
    */
   horizontal?: boolean | undefined;
   /**
@@ -347,29 +421,31 @@ type ScrollViewBaseProps = Readonly<{
    *
    * *Cross platform*
    *
-   *   - `'none'` (the default), drags do not dismiss the keyboard.
+   *   - `'none'`, drags do not dismiss the keyboard.
    *   - `'on-drag'`, the keyboard is dismissed when a drag begins.
    *
    * *iOS Only*
    *
    *   - `'interactive'`, the keyboard is dismissed interactively with the drag and moves in
    *     synchrony with the touch; dragging upwards cancels the dismissal.
-   *     On android this is not supported and it will have the same behavior as 'none'.
+   *     On Android this is not supported and it will have the same behavior as `'none'`.
+   *
+   * @default `'none'`
    */
   keyboardDismissMode?: ("none" | "on-drag" | "interactive") | undefined;
   /**
    * Determines when the keyboard should stay visible after a tap.
    *
-   *   - `'never'` (the default), tapping outside of the focused text input when the keyboard
-   *     is up dismisses the keyboard. When this happens, children won't receive the tap.
+   *   - `'never'`, tapping outside of the focused text input when the keyboard
+   *     is up dismisses the keyboard. When this happens, children will not receive the tap.
    *   - `'always'`, the keyboard will not dismiss automatically, and the scroll view will not
    *     catch taps, but children of the scroll view can catch taps.
    *   - `'handled'`, the keyboard will not dismiss automatically when the tap was handled by
-   *     a children, (or captured by an ancestor).
-   *   - `false`, deprecated, use 'never' instead
-   *   - `true`, deprecated, use 'always' instead
+   *     children, (or captured by an ancestor).
+   *
+   * @default `'never'`
    */
-  keyboardShouldPersistTaps?: ("always" | "never" | "handled" | true | false) | undefined;
+  keyboardShouldPersistTaps?: ("always" | "never" | "handled") | undefined;
   /**
    * When set, the scroll view will adjust the scroll position so that the first child that is
    * partially or fully visible and at or beyond `minIndexForVisible` will not change position.
@@ -427,22 +503,23 @@ type ScrollViewBaseProps = Readonly<{
    * It's implemented using onLayout handler attached to the content container
    * which this ScrollView renders.
    */
-  onContentSizeChange?: (contentWidth: number, contentHeight: number) => void;
-  onKeyboardDidShow?: (event: KeyboardEvent) => void;
-  onKeyboardDidHide?: (event: KeyboardEvent) => void;
-  onKeyboardWillShow?: (event: KeyboardEvent) => void;
-  onKeyboardWillHide?: (event: KeyboardEvent) => void;
+  onContentSizeChange?: ((contentWidth: number, contentHeight: number) => void) | undefined;
+  onKeyboardDidShow?: ((event: KeyboardEvent) => void) | undefined;
+  onKeyboardDidHide?: ((event: KeyboardEvent) => void) | undefined;
+  onKeyboardWillShow?: ((event: KeyboardEvent) => void) | undefined;
+  onKeyboardWillHide?: ((event: KeyboardEvent) => void) | undefined;
   /**
    * When true, the scroll view stops on multiples of the scroll view's size
-   * when scrolling. This can be used for horizontal pagination. The default
-   * value is false.
+   * when scrolling. This can be used for horizontal pagination.
+   *
+   * @default `false`
    */
   pagingEnabled?: boolean | undefined;
   /**
    * When false, the view cannot be scrolled via touch interaction.
-   * The default value is true.
-   *
    * Note that the view can always be scrolled by calling `scrollTo`.
+   *
+   * @default `true`
    */
   scrollEnabled?: boolean | undefined;
   /**
@@ -450,16 +527,21 @@ type ScrollViewBaseProps = Readonly<{
    * a time interval in ms. This may be useful when expensive work is performed
    * in response to scrolling. Values <= `16` will disable throttling,
    * regardless of the refresh rate of the device.
+   *
+   * @default `0`
    */
   scrollEventThrottle?: number | undefined;
   /**
    * When true, shows a vertical scroll indicator.
-   * The default value is true.
+   *
+   * @default `true`
    */
   showsVerticalScrollIndicator?: boolean | undefined;
   /**
-   * When true, Sticky header is hidden when scrolling down, and dock at the top
-   * when scrolling up
+   * When true, the sticky header is hidden when scrolling down, and docks
+   * at the top when scrolling up.
+   *
+   * @default `false`
    */
   stickyHeaderHiddenOnScroll?: boolean | undefined;
   /**
@@ -476,14 +558,16 @@ type ScrollViewBaseProps = Readonly<{
    * You may need to set this if your sticky header uses custom transforms (eg. translation),
    * for example when you want your list to have an animated hidable header.
    */
-  StickyHeaderComponent?: StickyHeaderComponentType;
+  StickyHeaderComponent?: StickyHeaderComponentType | undefined;
   /**
-   * When `snapToInterval` is set, `snapToAlignment` will define the relationship
+   * When `snapToInterval` is set, `snapToAlignment` defines the relationship
    * of the snapping to the scroll view.
    *
-   *   - `'start'` (the default) will align the snap at the left (horizontal) or top (vertical)
-   *   - `'center'` will align the snap in the center
-   *   - `'end'` will align the snap at the right (horizontal) or bottom (vertical)
+   *   - `'start'`, aligns the snap at the left (horizontal) or top (vertical).
+   *   - `'center'`, aligns the snap in the center.
+   *   - `'end'`, aligns the snap at the right (horizontal) or bottom (vertical).
+   *
+   * @default `'start'`
    */
   snapToAlignment?: ("start" | "center" | "end") | undefined;
   /**
@@ -506,25 +590,28 @@ type ScrollViewBaseProps = Readonly<{
   snapToOffsets?: ReadonlyArray<number> | undefined;
   /**
    * Use in conjunction with `snapToOffsets`. By default, the beginning
-   * of the list counts as a snap offset. Set `snapToStart` to false to disable
+   * of the list counts as a snap offset. Set `snapToStart` to `false` to disable
    * this behavior and allow the list to scroll freely between its start and
    * the first `snapToOffsets` offset.
-   * The default value is true.
+   *
+   * @default `true`
    */
   snapToStart?: boolean | undefined;
   /**
    * Use in conjunction with `snapToOffsets`. By default, the end
-   * of the list counts as a snap offset. Set `snapToEnd` to false to disable
+   * of the list counts as a snap offset. Set `snapToEnd` to `false` to disable
    * this behavior and allow the list to scroll freely between its end and
    * the last `snapToOffsets` offset.
-   * The default value is true.
+   *
+   * @default `true`
    */
   snapToEnd?: boolean | undefined;
   /**
    * Experimental: When true, offscreen child views (whose `overflow` value is
    * `hidden`) are removed from their native backing superview when offscreen.
-   * This can improve scrolling performance on long lists. The default value is
-   * true.
+   * This can improve scrolling performance on long lists.
+   *
+   * @default `true`
    */
   removeClippedSubviews?: boolean | undefined;
   /**
@@ -535,28 +622,65 @@ type ScrollViewBaseProps = Readonly<{
    * See [RefreshControl](docs/refreshcontrol.html).
    */
   refreshControl?: React.JSX.Element | undefined;
-  children?: React.ReactNode;
+  children?: React.ReactNode | undefined;
   /**
    * A ref to the inner View element of the ScrollView. This should be used
    * instead of calling `getInnerViewRef`.
    */
-  innerViewRef?: React.Ref<InnerViewInstance>;
+  innerViewRef?: React.Ref<InnerViewInstance> | undefined;
   /**
    * A ref to the Native ScrollView component. This ref can be used to call
    * all of ScrollView's public methods, in addition to native methods like
    * measure, measureLayout, etc.
    */
-  scrollViewRef?: React.Ref<PublicScrollViewInstance>;
+  scrollViewRef?: React.Ref<ScrollViewInstance> | undefined;
 }>;
-export type ScrollViewProps = Readonly<Omit<Omit<ViewProps, "experimental_accessibilityOrder">, keyof ScrollViewPropsIOS | keyof ScrollViewPropsAndroid | keyof ScrollViewBaseProps | keyof {}> & Omit<ScrollViewPropsIOS, keyof ScrollViewPropsAndroid | keyof ScrollViewBaseProps | keyof {}> & Omit<ScrollViewPropsAndroid, keyof ScrollViewBaseProps | keyof {}> & Omit<ScrollViewBaseProps, keyof {}> & {}>;
+export interface ScrollViewProps extends Readonly<Omit<Omit<ViewProps, "experimental_accessibilityOrder">, keyof ScrollViewPropsIOS | keyof ScrollViewPropsAndroid | keyof ScrollViewBaseProps | keyof {}> & Omit<ScrollViewPropsIOS, keyof ScrollViewPropsAndroid | keyof ScrollViewBaseProps | keyof {}> & Omit<ScrollViewPropsAndroid, keyof ScrollViewBaseProps | keyof {}> & Omit<ScrollViewBaseProps, keyof {}>> {}
 export type ScrollViewComponentStatics = Readonly<{
   Context: typeof ScrollViewContext;
 }>;
 declare const ScrollViewWrapper: (props: Omit<ScrollViewProps, keyof {
-  ref?: React.Ref<PublicScrollViewInstance>;
+  ref?: React.Ref<ScrollViewInstance> | undefined;
 }> & {
-  ref?: React.Ref<PublicScrollViewInstance>;
+  ref?: React.Ref<ScrollViewInstance> | undefined;
 }) => React.ReactNode;
+/**
+ * Component that wraps platform ScrollView while providing
+ * integration with touch locking "responder" system.
+ *
+ * Keep in mind that ScrollViews must have a bounded height in order to work,
+ * since they contain unbounded-height children into a bounded container (via
+ * a scroll interaction). In order to bound the height of a ScrollView, either
+ * set the height of the view directly (discouraged) or make sure all parent
+ * views have bounded height. Forgetting to transfer `{flex: 1}` down the
+ * view stack can lead to errors here, which the element inspector makes
+ * easy to debug.
+ *
+ * Doesn't yet support other contained responders from blocking this scroll
+ * view from becoming the responder.
+ *
+ *
+ * `<ScrollView>` vs [`<FlatList>`](https://reactnative.dev/docs/flatlist) - which one to use?
+ *
+ * `ScrollView` simply renders all its react child components at once. That
+ * makes it very easy to understand and use.
+ *
+ * On the other hand, this has a performance downside. Imagine you have a very
+ * long list of items you want to display, maybe several screens worth of
+ * content. Creating JS components and native views for everything all at once,
+ * much of which may not even be shown, will contribute to slow rendering and
+ * increased memory usage.
+ *
+ * This is where `FlatList` comes into play. `FlatList` renders items lazily,
+ * just when they are about to appear, and removes items that scroll way off
+ * screen to save memory and processing time.
+ *
+ * `FlatList` is also handy if you want to render separators between your items,
+ * multiple columns, infinite scroll loading, or any number of other features it
+ * supports out of the box.
+ *
+ * @see https://reactnative.dev/docs/scrollview
+ */
 declare const $$ScrollView: typeof ScrollViewWrapper & ScrollViewComponentStatics;
 declare type $$ScrollView = typeof $$ScrollView;
 export default $$ScrollView;

package/types_generated/Libraries/Components/ScrollView/ScrollViewStickyHeader.d.ts

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<f8dd9c647cf100daf63bfef26d661794>>
+ * @generated SignedSource<<2a2474f9ffeb2f444daca4629c021f62>>
  *
  * This file was translated from Flow by scripts/js-api/build-types/index.js.
  * Original file: packages/react-native/Libraries/Components/ScrollView/ScrollViewStickyHeader.js
@@ -14,7 +14,7 @@ import type { LayoutChangeEvent } from "../../Types/CoreEventTypes";
 import Animated from "../../Animated/Animated";
 import * as React from "react";
 export type ScrollViewStickyHeaderProps = Readonly<{
-  children?: React.ReactNode;
+  children?: React.ReactNode | undefined;
   nextHeaderLayoutY: number | undefined;
   onLayout: (event: LayoutChangeEvent) => void;
   scrollAnimatedValue: Animated.Value;
@@ -27,9 +27,9 @@ interface Instance extends React.ElementRef<typeof Animated.View> {
   readonly setNextHeaderY: ($$PARAM_0$$: number) => void;
 }
 declare const ScrollViewStickyHeader: (props: Omit<ScrollViewStickyHeaderProps, keyof {
-  ref?: React.Ref<Instance>;
+  ref?: React.Ref<Instance> | undefined;
 }> & {
-  ref?: React.Ref<Instance>;
+  ref?: React.Ref<Instance> | undefined;
 }) => React.ReactNode;
 declare const $$ScrollViewStickyHeader: typeof ScrollViewStickyHeader;
 declare type $$ScrollViewStickyHeader = typeof $$ScrollViewStickyHeader;