react-native-tvos 0.81.4-0 → 0.81.5-0

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

@@ -1,68 +0,0 @@
-/**
- * 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<<6e6dfd624c3554d720b469957c53af95>>
- *
- * This file was translated from Flow by scripts/build-types/index.js.
- * Original file: packages/react-native/Libraries/Image/ImageViewNativeComponent.js
- */
-
-import type { HostComponent } from "../../src/private/types/HostComponent";
-import type { HostInstance } from "../../src/private/types/HostInstance";
-import type { ViewProps } from "../Components/View/ViewPropTypes";
-import type { PartialViewConfig } from "../Renderer/shims/ReactNativeTypes";
-import type { ColorValue, DangerouslyImpreciseStyle, ImageStyleProp } from "../StyleSheet/StyleSheet";
-import type { ResolvedAssetSource } from "./AssetSourceResolver";
-import type { ImageProps } from "./ImageProps";
-import type { ImageSource } from "./ImageSource";
-type ImageHostComponentProps = Readonly<Omit<ImageProps, keyof ViewProps | keyof {
-  style?: ImageStyleProp | DangerouslyImpreciseStyle;
-  tintColor?: ColorValue;
-  shouldNotifyLoadEvents?: boolean;
-  src?: (ResolvedAssetSource | undefined) | (ReadonlyArray<Readonly<{
-    uri?: string | undefined;
-  }> | undefined> | undefined);
-  headers?: {
-    [$$Key$$: string]: string;
-  } | undefined;
-  defaultSource?: (ImageSource | undefined) | (string | undefined);
-  loadingIndicatorSrc?: string | undefined;
-}> & Omit<ViewProps, keyof {
-  style?: ImageStyleProp | DangerouslyImpreciseStyle;
-  tintColor?: ColorValue;
-  shouldNotifyLoadEvents?: boolean;
-  src?: (ResolvedAssetSource | undefined) | (ReadonlyArray<Readonly<{
-    uri?: string | undefined;
-  }> | undefined> | undefined);
-  headers?: {
-    [$$Key$$: string]: string;
-  } | undefined;
-  defaultSource?: (ImageSource | undefined) | (string | undefined);
-  loadingIndicatorSrc?: string | undefined;
-}> & {
-  style?: ImageStyleProp | DangerouslyImpreciseStyle;
-  tintColor?: ColorValue;
-  shouldNotifyLoadEvents?: boolean;
-  src?: (ResolvedAssetSource | undefined) | (ReadonlyArray<Readonly<{
-    uri?: string | undefined;
-  }> | undefined> | undefined);
-  headers?: {
-    [$$Key$$: string]: string;
-  } | undefined;
-  defaultSource?: (ImageSource | undefined) | (string | undefined);
-  loadingIndicatorSrc?: string | undefined;
-}>;
-interface NativeCommands {
-  readonly setIsVisible_EXPERIMENTAL: (viewRef: HostInstance, isVisible: boolean, time: number) => void;
-}
-export declare const Commands: NativeCommands;
-export declare type Commands = typeof Commands;
-export declare const __INTERNAL_VIEW_CONFIG: PartialViewConfig;
-export declare type __INTERNAL_VIEW_CONFIG = typeof __INTERNAL_VIEW_CONFIG;
-declare const ImageViewNativeComponent: HostComponent<ImageHostComponentProps>;
-declare const $$ImageViewNativeComponent: typeof ImageViewNativeComponent;
-declare type $$ImageViewNativeComponent = typeof $$ImageViewNativeComponent;
-export default $$ImageViewNativeComponent;

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

@@ -1,42 +0,0 @@
-/**
- * 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<<2599e35b506b6441c1270839d2b99e09>>
- *
- * This file was translated from Flow by scripts/build-types/index.js.
- * Original file: packages/react-native/Libraries/Image/TextInlineImageNativeComponent.js
- */
-
-import type { HostComponent } from "../../src/private/types/HostComponent";
-import type { ViewProps } from "../Components/View/ViewPropTypes";
-import type { PartialViewConfig } from "../Renderer/shims/ReactNativeTypes";
-import type { ColorValue } from "../StyleSheet/StyleSheet";
-import type { ImageResizeMode } from "./ImageResizeMode";
-type RCTTextInlineImageNativeProps = Readonly<Omit<ViewProps, keyof {
-  resizeMode?: ImageResizeMode | undefined;
-  src?: ReadonlyArray<Readonly<{
-    uri?: string | undefined;
-  }> | undefined> | undefined;
-  tintColor?: ColorValue | undefined;
-  headers?: {
-    [$$Key$$: string]: string;
-  } | undefined;
-}> & {
-  resizeMode?: ImageResizeMode | undefined;
-  src?: ReadonlyArray<Readonly<{
-    uri?: string | undefined;
-  }> | undefined> | undefined;
-  tintColor?: ColorValue | undefined;
-  headers?: {
-    [$$Key$$: string]: string;
-  } | undefined;
-}>;
-export declare const __INTERNAL_VIEW_CONFIG: PartialViewConfig;
-export declare type __INTERNAL_VIEW_CONFIG = typeof __INTERNAL_VIEW_CONFIG;
-declare const TextInlineImage: HostComponent<RCTTextInlineImageNativeProps>;
-declare const $$TextInlineImageNativeComponent: typeof TextInlineImage;
-declare type $$TextInlineImageNativeComponent = typeof $$TextInlineImageNativeComponent;
-export default $$TextInlineImageNativeComponent;

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

@@ -1,100 +0,0 @@
-/**
- * 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<<93cb8adad2c17bc64525934d6f7ef483>>
- *
- * This file was translated from Flow by scripts/build-types/index.js.
- * Original file: packages/react-native/Libraries/Interaction/InteractionManager.js
- */
-
-import type { EventSubscription } from "../vendor/emitter/EventEmitter";
-import type { Task } from "./TaskQueue";
-export type { Task, SimpleTask, PromiseTask } from "./TaskQueue";
-export type Handle = number;
-declare const InteractionManagerImpl: {
-  Events: {
-    interactionStart: "interactionStart";
-    interactionComplete: "interactionComplete";
-  };
-  /**
-   * Schedule a function to run after all interactions have completed. Returns a cancellable
-   * "promise".
-   */
-  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.
-   */
-  createInteractionHandle(): Handle;
-  /**
-   * Notify manager that an interaction has completed.
-   */
-  clearInteractionHandle(handle: Handle): void;
-  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).
-   */
-  setDeadline(deadline: number): void;
-};
-declare const InteractionManager: typeof InteractionManagerImpl;
-/**
- * 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 InteractionManager;
-declare type $$InteractionManager = typeof $$InteractionManager;
-export default $$InteractionManager;

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

@@ -1,231 +0,0 @@
-/**
- * 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<<75d3eaf45d8c583c6b07fa06a3e38f23>>
- *
- * This file was translated from Flow by scripts/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.
- *
- * By default, `PanResponder` holds an `InteractionManager` handle to block
- * long-running JS events from interrupting active 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/facebook/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/Interaction/TaskQueue.d.ts

@@ -1,73 +0,0 @@
-/**
- * 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<<e7abace7f371a88fb5adb2ad7734d9b1>>
- *
- * This file was translated from Flow by scripts/build-types/index.js.
- * Original file: packages/react-native/Libraries/Interaction/TaskQueue.js
- */
-
-export type SimpleTask = {
-  name: string;
-  run: () => void;
-};
-export type PromiseTask = {
-  name: string;
-  gen: () => Promise<void>;
-};
-export type Task = SimpleTask | PromiseTask | (() => void);
-/**
- * TaskQueue - A system for queueing and executing a mix of simple callbacks and
- * trees of dependent tasks based on Promises. No tasks are executed unless
- * `processNext` is called.
- *
- * `enqueue` takes a Task object with either a simple `run` callback, or a
- * `gen` function that returns a `Promise` and puts it in the queue.  If a gen
- * function is supplied, then the promise it returns will block execution of
- * tasks already in the queue until it resolves. This can be used to make sure
- * the first task is fully resolved (including asynchronous dependencies that
- * also schedule more tasks via `enqueue`) before starting on the next task.
- * The `onMoreTasks` constructor argument is used to inform the owner that an
- * async task has resolved and that the queue should be processed again.
- *
- * Note: Tasks are only actually executed with explicit calls to `processNext`.
- */
-declare class TaskQueue {
-  /**
-   * TaskQueue instances are self contained and independent, so multiple tasks
-   * of varying semantics and priority can operate together.
-   *
-   * `onMoreTasks` is invoked when `PromiseTask`s resolve if there are more
-   * tasks to process.
-   */
-  constructor($$PARAM_0$$: {
-    onMoreTasks: () => void;
-  });
-  /**
-   * Add a task to the queue.  It is recommended to name your tasks for easier
-   * async debugging. Tasks will not be executed until `processNext` is called
-   * explicitly.
-   */
-  enqueue(task: Task): void;
-  enqueueTasks(tasks: Array<Task>): void;
-  cancelTasks(tasksToCancel: Array<Task>): void;
-  /**
-   * Check to see if `processNext` should be called.
-   *
-   * @returns {boolean} Returns true if there are tasks that are ready to be
-   * processed with `processNext`, or returns false if there are no more tasks
-   * to be processed right now, although there may be tasks in the queue that
-   * are blocked by earlier `PromiseTask`s that haven't resolved yet.
-   * `onMoreTasks` will be called after each `PromiseTask` resolves if there are
-   * tasks ready to run at that point.
-   */
-  hasTasksToProcess(): boolean;
-  /**
-   * Executes the next task in the queue.
-   */
-  processNext(): void;
-}
-export default TaskQueue;

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

@@ -1,76 +0,0 @@
-/**
- * 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<<9665281b2ac7823758f058964ceec46a>>
- *
- * This file was translated from Flow by scripts/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

@@ -1,68 +0,0 @@
-/**
- * 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<<48a605c48a65a85b29efde935b0914f0>>
- *
- * This file was translated from Flow by scripts/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;