react-native-tvos 0.86.0-2 → 0.86.3-0

package/types_generated/Libraries/Image/ImageResizeMode.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated SignedSource<<d2a1976ea0d5cd19ca2eb0f425b0ad28>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Image/ImageResizeMode.js
+ */
+
+/**
+ * ImageResizeMode defines valid values for different image resizing modes set
+ * via the `resizeMode` style property on `<Image>`.
+ */
+export type ImageResizeMode = "center" | "contain" | "cover" | "repeat" | "stretch" | "none";

package/types_generated/Libraries/Image/ImageSource.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated SignedSource<<0dc503edc33fdb75bdf3f12b3e173f48>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Image/ImageSource.js
+ */
+
+/**
+ * This type is intentionally inexact in order to permit call sites that supply
+ * extra properties.
+ */
+export interface ImageURISource {
+  /**
+   * `uri` is a string representing the resource identifier for the image, which
+   * could be an http address, a local file path, or the name of a static image
+   * resource (which should be wrapped in the `require('./path/to/image.png')`
+   * function).
+   */
+  readonly uri?: string | undefined;
+  /**
+   * `bundle` is the iOS asset bundle which the image is included in. This
+   * will default to [NSBundle mainBundle] if not set.
+   * @platform ios
+   */
+  readonly bundle?: string | undefined;
+  /**
+   * `method` is the HTTP Method to use. Defaults to GET if not specified.
+   */
+  readonly method?: string | undefined;
+  /**
+   * `headers` is an object representing the HTTP headers to send along with the
+   * request for a remote image.
+   */
+  readonly headers?: {
+    [$$Key$$: string]: string;
+  } | undefined;
+  /**
+   * `body` is the HTTP body to send with the request. This must be a valid
+   * UTF-8 string, and will be sent exactly as specified, with no
+   * additional encoding (e.g. URL-escaping or base64) applied.
+   */
+  readonly body?: string | undefined;
+  /**
+   * `cache` determines how the requests handles potentially cached
+   * responses.
+   *
+   * - `default`: Use the native platforms default strategy. `useProtocolCachePolicy` on iOS.
+   *
+   * - `reload`: The data for the URL will be loaded from the originating source.
+   * No existing cache data should be used to satisfy a URL load request.
+   *
+   * - `force-cache`: The existing cached data will be used to satisfy the request,
+   * regardless of its age or expiration date. If there is no existing data in the cache
+   * corresponding the request, the data is loaded from the originating source.
+   *
+   * - `only-if-cached`: The existing cache data will be used to satisfy a request, regardless of
+   * its age or expiration date. If there is no existing data in the cache corresponding
+   * to a URL load request, no attempt is made to load the data from the originating source,
+   * and the load is considered to have failed.
+   */
+  readonly cache?: ("default" | "reload" | "force-cache" | "only-if-cached") | undefined;
+  /**
+   * `width` and `height` can be specified if known at build time, in which case
+   * these will be used to set the default `<Image/>` component dimensions.
+   */
+  readonly width?: number | undefined;
+  readonly height?: number | undefined;
+  /**
+   * `scale` is used to indicate the scale factor of the image. Defaults to 1.0 if
+   * unspecified, meaning that one image pixel equates to one display point / DIP.
+   */
+  readonly scale?: number | undefined;
+}
+export type ImageRequireSource = number;
+export type ImageSource = ImageRequireSource | ImageURISource | ReadonlyArray<ImageURISource>;
+type ImageSourceProperties = {
+  body?: string | undefined;
+  bundle?: string | undefined;
+  cache?: ("default" | "reload" | "force-cache" | "only-if-cached") | undefined;
+  headers?: {
+    [$$Key$$: string]: string;
+  } | undefined;
+  height?: number | undefined;
+  method?: string | undefined;
+  scale?: number | undefined;
+  uri?: string | undefined;
+  width?: number | undefined;
+};
+export declare function getImageSourceProperties(imageSource: ImageURISource): Readonly<ImageSourceProperties>;

package/types_generated/Libraries/Image/ImageTypes.flow.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated SignedSource<<be5e5f8ed460e8f99fe3ac0930ab4e78>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Image/ImageTypes.flow.js
+ */
+
+import type { HostInstance } from "../..";
+import type { RootTag } from "../Types/RootTagTypes";
+import type { ResolvedAssetSource } from "./AssetSourceResolver";
+import type { ImageProps as ImagePropsType } from "./ImageProps";
+import type { ImageSource } from "./ImageSource";
+import * as React from "react";
+export type ImageSize = {
+  width: number;
+  height: number;
+};
+export type ImageResolvedAssetSource = ResolvedAssetSource;
+type ImageComponentStaticsIOS = Readonly<{
+  getSize(uri: string): Promise<ImageSize>;
+  getSize(uri: string, success: (width: number, height: number) => void, failure?: (error: unknown) => void): void;
+  getSizeWithHeaders(uri: string, headers: {
+    [$$Key$$: string]: string;
+  }): Promise<ImageSize>;
+  getSizeWithHeaders(uri: string, headers: {
+    [$$Key$$: string]: string;
+  }, success: (width: number, height: number) => void, failure?: (error: unknown) => void): void;
+  prefetch(url: string): Promise<boolean>;
+  prefetchWithMetadata(url: string, queryRootName: string, rootTag?: RootTag | undefined): Promise<boolean>;
+  queryCache(urls: Array<string>): Promise<{
+    [url: string]: "memory" | "disk" | "disk/memory";
+  }>;
+  /**
+   * @see https://reactnative.dev/docs/image#resolveassetsource
+   */
+  resolveAssetSource(source: ImageSource): ImageResolvedAssetSource | undefined;
+}>;
+type ImageComponentStaticsAndroid = Readonly<Omit<ImageComponentStaticsIOS, keyof {
+  abortPrefetch(requestId: number): void;
+}> & {
+  abortPrefetch(requestId: number): void;
+}>;
+export type AbstractImageAndroid = (props: Omit<ImagePropsType, keyof {
+  ref?: React.Ref<HostInstance>;
+}> & {
+  ref?: React.Ref<HostInstance>;
+}) => React.ReactNode;
+export type ImageAndroid = AbstractImageAndroid & ImageComponentStaticsAndroid;
+export type AbstractImageIOS = (props: Omit<ImagePropsType, keyof {
+  ref?: React.Ref<HostInstance>;
+}> & {
+  ref?: React.Ref<HostInstance>;
+}) => React.ReactNode;
+export type ImageIOS = AbstractImageIOS & ImageComponentStaticsIOS;
+export type ImageType = ImageIOS | ImageAndroid;
+export type { ImageProps } from "./ImageProps";

package/types_generated/Libraries/Interaction/InteractionManager.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated SignedSource<<25d4684e56604de035c6bb597d9e14cb>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Interaction/InteractionManager.js
+ */
+
+import type { EventSubscription } from "../vendor/emitter/EventEmitter";
+export type SimpleTask = {
+  name: string;
+  run: () => void;
+};
+export type PromiseTask = {
+  name: string;
+  gen: () => Promise<void>;
+};
+export type Task = SimpleTask | PromiseTask | (() => void);
+export type Handle = number;
+declare const InteractionManagerStub: {
+  Events: {
+    interactionStart: "interactionStart";
+    interactionComplete: "interactionComplete";
+  };
+  /**
+   * Schedule a function to run after all interactions have completed. Returns a cancellable
+   * "promise".
+   *
+   * @deprecated
+   */
+  runAfterInteractions(task: null | undefined | Task): {
+    then: <U>(onFulfill?: (($$PARAM_0$$: void) => (Promise<U> | U) | undefined) | undefined, onReject?: ((error: unknown) => (Promise<U> | U) | undefined) | undefined) => Promise<U>;
+    cancel: () => void;
+  };
+  /**
+   * Notify manager that an interaction has started.
+   *
+   * @deprecated
+   */
+  createInteractionHandle(): Handle;
+  /**
+   * Notify manager that an interaction has completed.
+   *
+   * @deprecated
+   */
+  clearInteractionHandle(handle: Handle): void;
+  /**
+   * @deprecated
+   */
+  addListener(eventType: string, listener: (...args: any) => unknown, context: unknown): EventSubscription;
+  /**
+   * A positive number will use setTimeout to schedule any tasks after the
+   * eventLoopRunningTime hits the deadline value, otherwise all tasks will be
+   * executed in one setImmediate batch (default).
+   *
+   * @deprecated
+   */
+  setDeadline(deadline: number): void;
+};
+/**
+ * InteractionManager allows long-running work to be scheduled after any
+ * interactions/animations have completed. In particular, this allows JavaScript
+ * animations to run smoothly.
+ *
+ * Applications can schedule tasks to run after interactions with the following:
+ *
+ * ```
+ * InteractionManager.runAfterInteractions(() => {
+ *   // ...long-running synchronous task...
+ * });
+ * ```
+ *
+ * Compare this to other scheduling alternatives:
+ *
+ * - requestAnimationFrame(): for code that animates a view over time.
+ * - setImmediate/setTimeout(): run code later, note this may delay animations.
+ * - runAfterInteractions(): run code later, without delaying active animations.
+ *
+ * The touch handling system considers one or more active touches to be an
+ * 'interaction' and will delay `runAfterInteractions()` callbacks until all
+ * touches have ended or been cancelled.
+ *
+ * InteractionManager also allows applications to register animations by
+ * creating an interaction 'handle' on animation start, and clearing it upon
+ * completion:
+ *
+ * ```
+ * var handle = InteractionManager.createInteractionHandle();
+ * // run animation... (`runAfterInteractions` tasks are queued)
+ * // later, on animation completion:
+ * InteractionManager.clearInteractionHandle(handle);
+ * // queued tasks run if all handles were cleared
+ * ```
+ *
+ * `runAfterInteractions` takes either a plain callback function, or a
+ * `PromiseTask` object with a `gen` method that returns a `Promise`.  If a
+ * `PromiseTask` is supplied, then it is fully resolved (including asynchronous
+ * dependencies that also schedule more tasks via `runAfterInteractions`) before
+ * starting on the next task that might have been queued up synchronously
+ * earlier.
+ *
+ * By default, queued tasks are executed together in a loop in one
+ * `setImmediate` batch. If `setDeadline` is called with a positive number, then
+ * tasks will only be executed until the deadline (in terms of js event loop run
+ * time) approaches, at which point execution will yield via setTimeout,
+ * allowing events such as touches to start interactions and block queued tasks
+ * from executing, making apps more responsive.
+ *
+ * @deprecated
+ */
+declare const $$InteractionManager: typeof InteractionManagerStub;
+declare type $$InteractionManager = typeof $$InteractionManager;
+export default $$InteractionManager;

package/types_generated/Libraries/Interaction/PanResponder.d.ts

@@ -0,0 +1,228 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated SignedSource<<d55e74e2efd5ee21a5a6947b85b1c69f>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Interaction/PanResponder.js
+ */
+
+import type { GestureResponderEvent } from "../Types/CoreEventTypes";
+/**
+ * `PanResponder` reconciles several touches into a single gesture. It makes
+ * single-touch gestures resilient to extra touches, and can be used to
+ * recognize simple multi-touch gestures.
+ *
+ * It provides a predictable wrapper of the responder handlers provided by the
+ * [gesture responder system](docs/gesture-responder-system.html).
+ * For each handler, it provides a new `gestureState` object alongside the
+ * native event object:
+ *
+ * ```
+ * onPanResponderMove: (event, gestureState) => {}
+ * ```
+ *
+ * A native event is a synthetic touch event with the following form:
+ *
+ *  - `nativeEvent`
+ *      + `changedTouches` - Array of all touch events that have changed since the last event
+ *      + `identifier` - The ID of the touch
+ *      + `locationX` - The X position of the touch, relative to the element
+ *      + `locationY` - The Y position of the touch, relative to the element
+ *      + `pageX` - The X position of the touch, relative to the root element
+ *      + `pageY` - The Y position of the touch, relative to the root element
+ *      + `target` - The node id of the element receiving the touch event
+ *      + `timestamp` - A time identifier for the touch, useful for velocity calculation
+ *      + `touches` - Array of all current touches on the screen
+ *
+ * A `gestureState` object has the following:
+ *
+ *  - `stateID` - ID of the gestureState- persisted as long as there at least
+ *     one touch on screen
+ *  - `moveX` - the latest screen coordinates of the recently-moved touch
+ *  - `moveY` - the latest screen coordinates of the recently-moved touch
+ *  - `x0` - the screen coordinates of the responder grant
+ *  - `y0` - the screen coordinates of the responder grant
+ *  - `dx` - accumulated distance of the gesture since the touch started
+ *  - `dy` - accumulated distance of the gesture since the touch started
+ *  - `vx` - current velocity of the gesture
+ *  - `vy` - current velocity of the gesture
+ *  - `numberActiveTouches` - Number of touches currently on screen
+ *
+ * ### Basic Usage
+ *
+ * ```
+ *   componentWillMount: function() {
+ *     this._panResponder = PanResponder.create({
+ *       // Ask to be the responder:
+ *       onStartShouldSetPanResponder: (evt, gestureState) => true,
+ *       onStartShouldSetPanResponderCapture: (evt, gestureState) => true,
+ *       onMoveShouldSetPanResponder: (evt, gestureState) => true,
+ *       onMoveShouldSetPanResponderCapture: (evt, gestureState) => true,
+ *
+ *       onPanResponderGrant: (evt, gestureState) => {
+ *         // The gesture has started. Show visual feedback so the user knows
+ *         // what is happening!
+ *
+ *         // gestureState.d{x,y} will be set to zero now
+ *       },
+ *       onPanResponderMove: (evt, gestureState) => {
+ *         // The most recent move distance is gestureState.move{X,Y}
+ *
+ *         // The accumulated gesture distance since becoming responder is
+ *         // gestureState.d{x,y}
+ *       },
+ *       onPanResponderTerminationRequest: (evt, gestureState) => true,
+ *       onPanResponderRelease: (evt, gestureState) => {
+ *         // The user has released all touches while this view is the
+ *         // responder. This typically means a gesture has succeeded
+ *       },
+ *       onPanResponderTerminate: (evt, gestureState) => {
+ *         // Another component has become the responder, so this gesture
+ *         // should be cancelled
+ *       },
+ *       onShouldBlockNativeResponder: (evt, gestureState) => {
+ *         // Returns whether this component should block native components from becoming the JS
+ *         // responder. Returns true by default. Is currently only supported on android.
+ *         return true;
+ *       },
+ *     });
+ *   },
+ *
+ *   render: function() {
+ *     return (
+ *       <View {...this._panResponder.panHandlers} />
+ *     );
+ *   },
+ *
+ * ```
+ *
+ * ### Working Example
+ *
+ * To see it in action, try the
+ * [PanResponder example in RNTester](https://github.com/react/react-native/blob/HEAD/packages/rn-tester/js/examples/PanResponder/PanResponderExample.js)
+ */
+
+export type PanResponderGestureState = {
+  /**
+   * ID of the gestureState - persisted as long as there at least one touch on screen
+   */
+  stateID: number;
+  /**
+   * The latest screen coordinates of the recently-moved touch
+   */
+  moveX: number;
+  /**
+   * The latest screen coordinates of the recently-moved touch
+   */
+  moveY: number;
+  /**
+   * The screen coordinates of the responder grant
+   */
+  x0: number;
+  /**
+   * The screen coordinates of the responder grant
+   */
+  y0: number;
+  /**
+   * Accumulated distance of the gesture since the touch started
+   */
+  dx: number;
+  /**
+   * Accumulated distance of the gesture since the touch started
+   */
+  dy: number;
+  /**
+   * Current velocity of the gesture
+   */
+  vx: number;
+  /**
+   * Current velocity of the gesture
+   */
+  vy: number;
+  /**
+   * Number of touches currently on screen
+   */
+  numberActiveTouches: number;
+};
+type ActiveCallback = (event: GestureResponderEvent, gestureState: PanResponderGestureState) => boolean;
+type PassiveCallback = (event: GestureResponderEvent, gestureState: PanResponderGestureState) => unknown;
+export type GestureResponderHandlerMethods = {
+  onMoveShouldSetResponder: (event: GestureResponderEvent) => boolean;
+  onMoveShouldSetResponderCapture: (event: GestureResponderEvent) => boolean;
+  onResponderEnd: (event: GestureResponderEvent) => void;
+  onResponderGrant: (event: GestureResponderEvent) => boolean;
+  onResponderMove: (event: GestureResponderEvent) => void;
+  onResponderReject: (event: GestureResponderEvent) => void;
+  onResponderRelease: (event: GestureResponderEvent) => void;
+  onResponderStart: (event: GestureResponderEvent) => void;
+  onResponderTerminate: (event: GestureResponderEvent) => void;
+  onResponderTerminationRequest: (event: GestureResponderEvent) => boolean;
+  onStartShouldSetResponder: (event: GestureResponderEvent) => boolean;
+  onStartShouldSetResponderCapture: (event: GestureResponderEvent) => boolean;
+};
+export type PanResponderCallbacks = Readonly<{
+  onMoveShouldSetPanResponder?: ActiveCallback | undefined;
+  onMoveShouldSetPanResponderCapture?: ActiveCallback | undefined;
+  onStartShouldSetPanResponder?: ActiveCallback | undefined;
+  onStartShouldSetPanResponderCapture?: ActiveCallback | undefined;
+  /**
+   * The body of `onResponderGrant` returns a bool, but the vast majority of
+   * callsites return void and this TODO notice is found in it:
+   *   TODO: t7467124 investigate if this can be removed
+   */
+  onPanResponderGrant?: (PassiveCallback | ActiveCallback) | undefined;
+  onPanResponderReject?: PassiveCallback | undefined;
+  onPanResponderStart?: PassiveCallback | undefined;
+  onPanResponderEnd?: PassiveCallback | undefined;
+  onPanResponderRelease?: PassiveCallback | undefined;
+  onPanResponderMove?: PassiveCallback | undefined;
+  onPanResponderTerminate?: PassiveCallback | undefined;
+  onPanResponderTerminationRequest?: ActiveCallback | undefined;
+  onShouldBlockNativeResponder?: ActiveCallback | undefined;
+}>;
+declare const PanResponder: {
+  /**
+   * @param {object} config Enhanced versions of all of the responder callbacks
+   * that provide not only the typical `ResponderSyntheticEvent`, but also the
+   * `PanResponder` gesture state.  Simply replace the word `Responder` with
+   * `PanResponder` in each of the typical `onResponder*` callbacks. For
+   * example, the `config` object would look like:
+   *
+   *  - `onMoveShouldSetPanResponder: (e, gestureState) => {...}`
+   *  - `onMoveShouldSetPanResponderCapture: (e, gestureState) => {...}`
+   *  - `onStartShouldSetPanResponder: (e, gestureState) => {...}`
+   *  - `onStartShouldSetPanResponderCapture: (e, gestureState) => {...}`
+   *  - `onPanResponderReject: (e, gestureState) => {...}`
+   *  - `onPanResponderGrant: (e, gestureState) => {...}`
+   *  - `onPanResponderStart: (e, gestureState) => {...}`
+   *  - `onPanResponderEnd: (e, gestureState) => {...}`
+   *  - `onPanResponderRelease: (e, gestureState) => {...}`
+   *  - `onPanResponderMove: (e, gestureState) => {...}`
+   *  - `onPanResponderTerminate: (e, gestureState) => {...}`
+   *  - `onPanResponderTerminationRequest: (e, gestureState) => {...}`
+   *  - `onShouldBlockNativeResponder: (e, gestureState) => {...}`
+   *
+   *  In general, for events that have capture equivalents, we update the
+   *  gestureState once in the capture phase and can use it in the bubble phase
+   *  as well.
+   *
+   *  Be careful with onStartShould* callbacks. They only reflect updated
+   *  `gestureState` for start/end events that bubble/capture to the Node.
+   *  Once the node is the responder, you can rely on every start/end event
+   *  being processed by the gesture and `gestureState` being updated
+   *  accordingly. (numberActiveTouches) may not be totally accurate unless you
+   *  are the responder.
+   */
+  create(config: PanResponderCallbacks): {
+    getInteractionHandle: () => number | undefined;
+    panHandlers: GestureResponderHandlerMethods;
+  };
+};
+export type PanResponderInstance = ReturnType<(typeof PanResponder)["create"]>;
+declare const $$PanResponder: typeof PanResponder;
+declare type $$PanResponder = typeof $$PanResponder;
+export default $$PanResponder;

package/types_generated/Libraries/LayoutAnimation/LayoutAnimation.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated SignedSource<<c16cf115fa244072ea249a1a16dd7ada>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/LayoutAnimation/LayoutAnimation.js
+ */
+
+import type { LayoutAnimationConfig, LayoutAnimationProperty, LayoutAnimationType } from "../Renderer/shims/ReactNativeTypes";
+export type { LayoutAnimationType, LayoutAnimationProperty, LayoutAnimationAnimationConfig as LayoutAnimationAnim } from "../Renderer/shims/ReactNativeTypes";
+export type { LayoutAnimationConfig } from "../Renderer/shims/ReactNativeTypes";
+export type LayoutAnimationTypes = Readonly<{ [type in LayoutAnimationType]: type }>;
+export type LayoutAnimationProperties = Readonly<{ [prop in LayoutAnimationProperty]: prop }>;
+type OnAnimationDidEndCallback = () => void;
+type OnAnimationDidFailCallback = () => void;
+declare function setLayoutAnimationEnabled(value: boolean): void;
+/**
+ * Configures the next commit to be animated.
+ *
+ * onAnimationDidEnd is guaranteed to be called when the animation completes.
+ * onAnimationDidFail is *never* called in the classic, pre-Fabric renderer,
+ * and never has been. In the new renderer (Fabric) it is called only if configuration
+ * parsing fails.
+ */
+declare function configureNext(config: LayoutAnimationConfig, onAnimationDidEnd?: OnAnimationDidEndCallback, onAnimationDidFail?: OnAnimationDidFailCallback): void;
+declare function createLayoutAnimation(duration: number, type?: LayoutAnimationType, property?: LayoutAnimationProperty): LayoutAnimationConfig;
+declare const Presets: {
+  easeInEaseOut: LayoutAnimationConfig;
+  linear: LayoutAnimationConfig;
+  spring: LayoutAnimationConfig;
+};
+declare const LayoutAnimation: {
+  /**
+   * Schedules an animation to happen on the next layout.
+   *
+   * @param config Specifies animation properties:
+   *
+   *   - `duration` in milliseconds
+   *   - `create`, `AnimationConfig` for animating in new views
+   *   - `update`, `AnimationConfig` for animating views that have been updated
+   *
+   * @param onAnimationDidEnd Called when the animation finished.
+   * Only supported on iOS.
+   * @param onError Called on error. Only supported on iOS.
+   */
+  configureNext: typeof configureNext;
+  /**
+   * Helper for creating a config for `configureNext`.
+   */
+  create: typeof createLayoutAnimation;
+  Types: LayoutAnimationTypes;
+  Properties: LayoutAnimationProperties;
+  checkConfig(...args: Array<unknown>): void;
+  Presets: typeof Presets;
+  easeInEaseOut: (onAnimationDidEnd?: OnAnimationDidEndCallback) => void;
+  linear: (onAnimationDidEnd?: OnAnimationDidEndCallback) => void;
+  spring: (onAnimationDidEnd?: OnAnimationDidEndCallback) => void;
+  setEnabled: typeof setLayoutAnimationEnabled;
+};
+/**
+ * Automatically animates views to their new positions when the
+ * next layout happens.
+ *
+ * A common way to use this API is to call it before calling `setState`.
+ *
+ * Note that in order to get this to work on **Android** you need to set the following flags via `UIManager`:
+ *
+ *     UIManager.setLayoutAnimationEnabledExperimental && UIManager.setLayoutAnimationEnabledExperimental(true);
+ */
+declare const $$LayoutAnimation: typeof LayoutAnimation;
+declare type $$LayoutAnimation = typeof $$LayoutAnimation;
+export default $$LayoutAnimation;

package/types_generated/Libraries/Linking/Linking.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated SignedSource<<cfe12ab4e47faca1a7b8a598363e1b66>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Linking/Linking.js
+ */
+
+import type { EventSubscription } from "../vendor/emitter/EventEmitter";
+import NativeEventEmitter from "../EventEmitter/NativeEventEmitter";
+type LinkingEventDefinitions = {
+  url: [{
+    url: string;
+  }];
+};
+declare class LinkingImpl extends NativeEventEmitter<LinkingEventDefinitions> {
+  constructor();
+  /**
+   * Add a handler to Linking changes by listening to the `url` event type
+   * and providing the handler
+   *
+   * See https://reactnative.dev/docs/linking#addeventlistener
+   */
+  addEventListener<K extends keyof LinkingEventDefinitions>(eventType: K, listener: (...$$REST$$: LinkingEventDefinitions[K]) => unknown): EventSubscription;
+  /**
+   * Try to open the given `url` with any of the installed apps.
+   *
+   * See https://reactnative.dev/docs/linking#openurl
+   */
+  openURL(url: string): Promise<void>;
+  /**
+   * Determine whether or not an installed app can handle a given URL.
+   *
+   * See https://reactnative.dev/docs/linking#canopenurl
+   */
+  canOpenURL(url: string): Promise<boolean>;
+  /**
+   * Open app settings.
+   *
+   * See https://reactnative.dev/docs/linking#opensettings
+   */
+  openSettings(): Promise<void>;
+  /**
+   * If the app launch was triggered by an app link,
+   * it will give the link url, otherwise it will give `null`
+   *
+   * See https://reactnative.dev/docs/linking#getinitialurl
+   */
+  getInitialURL(): Promise<null | undefined | string>;
+  sendIntent(action: string, extras?: Array<{
+    key: string;
+    value: string | number | boolean;
+  }>): Promise<void>;
+}
+declare const Linking: LinkingImpl;
+/**
+ * `Linking` gives you a general interface to interact with both incoming
+ * and outgoing app links.
+ *
+ * See https://reactnative.dev/docs/linking
+ */
+declare const $$Linking: typeof Linking;
+declare type $$Linking = typeof $$Linking;
+export default $$Linking;