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

package/types_generated/Libraries/Animated/AnimatedImplementation.d.ts

@@ -0,0 +1,128 @@
+/**
+ * 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<<de49cd48a2d8c2295712c9deed76cb1b>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Animated/AnimatedImplementation.js
+ */
+
+import type { EventConfig, Mapping } from "./AnimatedEvent";
+import type { EndCallback } from "./animations/Animation";
+import type { DecayAnimationConfig } from "./animations/DecayAnimation";
+import type { SpringAnimationConfig } from "./animations/SpringAnimation";
+import type { TimingAnimationConfig } from "./animations/TimingAnimation";
+import { AnimatedEvent, attachNativeEventImpl } from "./AnimatedEvent";
+import createAnimatedComponent from "./createAnimatedComponent";
+import AnimatedAddition from "./nodes/AnimatedAddition";
+import AnimatedColor from "./nodes/AnimatedColor";
+import AnimatedDiffClamp from "./nodes/AnimatedDiffClamp";
+import AnimatedDivision from "./nodes/AnimatedDivision";
+import AnimatedInterpolation from "./nodes/AnimatedInterpolation";
+import AnimatedModulo from "./nodes/AnimatedModulo";
+import AnimatedMultiplication from "./nodes/AnimatedMultiplication";
+import AnimatedNode from "./nodes/AnimatedNode";
+import AnimatedSubtraction from "./nodes/AnimatedSubtraction";
+import AnimatedValue from "./nodes/AnimatedValue";
+import AnimatedValueXY from "./nodes/AnimatedValueXY";
+export type CompositeAnimation = {
+  start: (callback?: EndCallback | undefined, isLooping?: boolean) => void;
+  stop: () => void;
+  reset: () => void;
+};
+declare const addImpl: (a: AnimatedNode | number, b: AnimatedNode | number) => AnimatedAddition;
+declare const subtractImpl: (a: AnimatedNode | number, b: AnimatedNode | number) => AnimatedSubtraction;
+declare const divideImpl: (a: AnimatedNode | number, b: AnimatedNode | number) => AnimatedDivision;
+declare const multiplyImpl: (a: AnimatedNode | number, b: AnimatedNode | number) => AnimatedMultiplication;
+declare const moduloImpl: (a: AnimatedNode, modulus: number) => AnimatedModulo;
+declare const diffClampImpl: (a: AnimatedNode, min: number, max: number) => AnimatedDiffClamp;
+declare const springImpl: (value: AnimatedValue | AnimatedValueXY | AnimatedColor, config: SpringAnimationConfig) => CompositeAnimation;
+declare const timingImpl: (value: AnimatedValue | AnimatedValueXY | AnimatedColor, config: TimingAnimationConfig) => CompositeAnimation;
+declare const decayImpl: (value: AnimatedValue | AnimatedValueXY | AnimatedColor, config: DecayAnimationConfig) => CompositeAnimation;
+declare const sequenceImpl: (animations: Array<CompositeAnimation>) => CompositeAnimation;
+type ParallelConfig = {
+  stopTogether?: boolean;
+};
+declare const parallelImpl: (animations: Array<CompositeAnimation>, config?: null | undefined | ParallelConfig) => CompositeAnimation;
+declare const delayImpl: (time: number) => CompositeAnimation;
+declare const staggerImpl: (time: number, animations: Array<CompositeAnimation>) => CompositeAnimation;
+type LoopAnimationConfig = {
+  iterations: number;
+  resetBeforeIteration?: boolean;
+};
+declare const loopImpl: (animation: CompositeAnimation, $$PARAM_1$$?: LoopAnimationConfig) => CompositeAnimation;
+declare function forkEventImpl(event: (null | undefined | AnimatedEvent) | (null | undefined | Function), listener: Function): AnimatedEvent | Function;
+declare function unforkEventImpl(event: (null | undefined | AnimatedEvent) | (null | undefined | Function), listener: Function): void;
+declare const eventImpl: <T>(argMapping: ReadonlyArray<null | undefined | Mapping>, config: EventConfig<T>) => any;
+type AnimatedNumeric = AnimatedAddition | AnimatedDiffClamp | AnimatedDivision | AnimatedInterpolation<number> | AnimatedModulo | AnimatedMultiplication | AnimatedSubtraction | AnimatedValue;
+export type { AnimatedNumeric as Numeric };
+/**
+ * The `Animated` library is designed to make animations fluid, powerful, and
+ * easy to build and maintain. `Animated` focuses on declarative relationships
+ * between inputs and outputs, with configurable transforms in between, and
+ * simple `start`/`stop` methods to control time-based animation execution.
+ * If additional transforms are added, be sure to include them in
+ * AnimatedMock.js as well.
+ *
+ * See https://reactnative.dev/docs/animated
+ */
+declare const $$AnimatedImplementation: {
+  /**
+   * Standard value class for driving animations.  Typically initialized with
+   * `new Animated.Value(0);`
+   *
+   * See https://reactnative.dev/docs/animated#value
+   */
+  Value: typeof AnimatedValue;
+  /**
+   * 2D value class for driving 2D animations, such as pan gestures.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy
+   */
+  ValueXY: typeof AnimatedValueXY;
+  /**
+   * Value class for driving color animations.
+   */
+  Color: typeof AnimatedColor;
+  /**
+   * Exported to use the Interpolation type in flow.
+   *
+   * See https://reactnative.dev/docs/animated#interpolation
+   */
+  Interpolation: typeof AnimatedInterpolation;
+  /**
+   * Exported for ease of type checking. All animated values derive from this
+   * class.
+   *
+   * See https://reactnative.dev/docs/animated#node
+   */
+  Node: typeof AnimatedNode;
+  decay: typeof decayImpl;
+  timing: typeof timingImpl;
+  spring: typeof springImpl;
+  add: typeof addImpl;
+  subtract: typeof subtractImpl;
+  divide: typeof divideImpl;
+  multiply: typeof multiplyImpl;
+  modulo: typeof moduloImpl;
+  diffClamp: typeof diffClampImpl;
+  delay: typeof delayImpl;
+  sequence: typeof sequenceImpl;
+  parallel: typeof parallelImpl;
+  stagger: typeof staggerImpl;
+  loop: typeof loopImpl;
+  event: typeof eventImpl;
+  createAnimatedComponent: typeof createAnimatedComponent;
+  attachNativeEvent: typeof attachNativeEventImpl;
+  forkEvent: typeof forkEventImpl;
+  unforkEvent: typeof unforkEventImpl;
+  /**
+   * Expose Event class, so it can be used as a type for type checkers.
+   */
+  Event: typeof AnimatedEvent;
+};
+declare type $$AnimatedImplementation = typeof $$AnimatedImplementation;
+export default $$AnimatedImplementation;

package/types_generated/Libraries/Animated/AnimatedPlatformConfig.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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<<f114eadc67180861d9b534a3bd091244>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Animated/AnimatedPlatformConfig.js
+ */
+
+export type PlatformConfig = {};

package/types_generated/Libraries/Animated/Easing.d.ts

@@ -0,0 +1,171 @@
+/**
+ * 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<<7aab100b465cd6aa59228aad106be5a3>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Animated/Easing.js
+ */
+
+export type EasingFunction = (t: number) => number;
+declare const EasingStatic: {
+  /**
+   * A stepping function, returns 1 for any positive value of `n`.
+   */
+  step0(n: number): number;
+  /**
+   * A stepping function, returns 1 if `n` is greater than or equal to 1.
+   */
+  step1(n: number): number;
+  /**
+   * A linear function, `f(t) = t`. Position correlates to elapsed time one to
+   * one.
+   *
+   * http://cubic-bezier.com/#0,0,1,1
+   */
+  linear(t: number): number;
+  /**
+   * A simple inertial interaction, similar to an object slowly accelerating to
+   * speed.
+   *
+   * http://cubic-bezier.com/#.42,0,1,1
+   */
+  ease(t: number): number;
+  /**
+   * A quadratic function, `f(t) = t * t`. Position equals the square of elapsed
+   * time.
+   *
+   * http://easings.net/#easeInQuad
+   */
+  quad(t: number): number;
+  /**
+   * A cubic function, `f(t) = t * t * t`. Position equals the cube of elapsed
+   * time.
+   *
+   * http://easings.net/#easeInCubic
+   */
+  cubic(t: number): number;
+  /**
+   * A power function. Position is equal to the Nth power of elapsed time.
+   *
+   * n = 4: http://easings.net/#easeInQuart
+   * n = 5: http://easings.net/#easeInQuint
+   */
+  poly(n: number): EasingFunction;
+  /**
+   * A sinusoidal function.
+   *
+   * http://easings.net/#easeInSine
+   */
+  sin(t: number): number;
+  /**
+   * A circular function.
+   *
+   * http://easings.net/#easeInCirc
+   */
+  circle(t: number): number;
+  /**
+   * An exponential function.
+   *
+   * http://easings.net/#easeInExpo
+   */
+  exp(t: number): number;
+  /**
+   * A simple elastic interaction, similar to a spring oscillating back and
+   * forth.
+   *
+   * Default bounciness is 1, which overshoots a little bit once. 0 bounciness
+   * doesn't overshoot at all, and bounciness of N > 1 will overshoot about N
+   * times.
+   *
+   * http://easings.net/#easeInElastic
+   */
+  elastic(bounciness?: number): EasingFunction;
+  /**
+   * Use with `Animated.parallel()` to create a simple effect where the object
+   * animates back slightly as the animation starts.
+   *
+   * https://easings.net/#easeInBack
+   */
+  back(s?: number): EasingFunction;
+  /**
+   * Provides a simple bouncing effect.
+   *
+   * http://easings.net/#easeInBounce
+   */
+  bounce(t: number): number;
+  /**
+   * Provides a cubic bezier curve, equivalent to CSS Transitions'
+   * `transition-timing-function`.
+   *
+   * A useful tool to visualize cubic bezier curves can be found at
+   * http://cubic-bezier.com/
+   */
+  bezier(x1: number, y1: number, x2: number, y2: number): EasingFunction;
+  /**
+   * Runs an easing function forwards.
+   */
+  in(easing: EasingFunction): EasingFunction;
+  /**
+   * Runs an easing function backwards.
+   */
+  out(easing: EasingFunction): EasingFunction;
+  /**
+   * Makes any easing function symmetrical. The easing function will run
+   * forwards for half of the duration, then backwards for the rest of the
+   * duration.
+   */
+  inOut(easing: EasingFunction): EasingFunction;
+};
+export type Easing = typeof EasingStatic;
+/**
+ * The `Easing` module implements common easing functions. This module is used
+ * by [Animate.timing()](docs/animate.html#timing) to convey physically
+ * believable motion in animations.
+ *
+ * You can find a visualization of some common easing functions at
+ * http://easings.net/
+ *
+ * ### Predefined animations
+ *
+ * The `Easing` module provides several predefined animations through the
+ * following methods:
+ *
+ * - [`back`](docs/easing.html#back) provides a simple animation where the
+ *   object goes slightly back before moving forward
+ * - [`bounce`](docs/easing.html#bounce) provides a bouncing animation
+ * - [`ease`](docs/easing.html#ease) provides a simple inertial animation
+ * - [`elastic`](docs/easing.html#elastic) provides a simple spring interaction
+ *
+ * ### Standard functions
+ *
+ * Three standard easing functions are provided:
+ *
+ * - [`linear`](docs/easing.html#linear)
+ * - [`quad`](docs/easing.html#quad)
+ * - [`cubic`](docs/easing.html#cubic)
+ *
+ * The [`poly`](docs/easing.html#poly) function can be used to implement
+ * quartic, quintic, and other higher power functions.
+ *
+ * ### Additional functions
+ *
+ * Additional mathematical functions are provided by the following methods:
+ *
+ * - [`bezier`](docs/easing.html#bezier) provides a cubic bezier curve
+ * - [`circle`](docs/easing.html#circle) provides a circular function
+ * - [`sin`](docs/easing.html#sin) provides a sinusoidal function
+ * - [`exp`](docs/easing.html#exp) provides an exponential function
+ *
+ * The following helpers are used to modify other easing functions.
+ *
+ * - [`in`](docs/easing.html#in) runs an easing function forwards
+ * - [`inOut`](docs/easing.html#inout) makes any easing function symmetrical
+ * - [`out`](docs/easing.html#out) runs an easing function backwards
+ */
+declare const $$Easing: typeof EasingStatic;
+declare type $$Easing = typeof $$Easing;
+export default $$Easing;

package/types_generated/Libraries/Animated/animations/Animation.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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<<4fb9efab93fb4702e15de0553054091f>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Animated/animations/Animation.js
+ */
+
+import type { PlatformConfig } from "../AnimatedPlatformConfig";
+import type AnimatedValue from "../nodes/AnimatedValue";
+export type EndResult = {
+  finished: boolean;
+  value?: number;
+  offset?: number;
+};
+export type EndCallback = (result: EndResult) => void;
+export type AnimationConfig = Readonly<{
+  isInteraction?: boolean;
+  useNativeDriver: boolean;
+  platformConfig?: PlatformConfig;
+  onComplete?: EndCallback | undefined;
+  iterations?: number;
+  isLooping?: boolean;
+  debugID?: string | undefined;
+}>;
+declare class Animation {
+  constructor(config: AnimationConfig);
+  start(fromValue: number, onUpdate: (value: number) => void, onEnd: null | undefined | EndCallback, previousAnimation: null | undefined | Animation, animatedValue: AnimatedValue): void;
+  stop(): void;
+}
+export default Animation;

package/types_generated/Libraries/Animated/animations/DecayAnimation.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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<<7385fd5e71640f4c18287ec1c64d91b7>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Animated/animations/DecayAnimation.js
+ */
+
+import type AnimatedValue from "../nodes/AnimatedValue";
+import type { AnimationConfig, EndCallback } from "./Animation";
+import Animation from "./Animation";
+export type DecayAnimationConfig = Readonly<Omit<AnimationConfig, keyof {
+  velocity: number | Readonly<{
+    x: number;
+    y: number;
+  }>;
+  deceleration?: number;
+}> & {
+  velocity: number | Readonly<{
+    x: number;
+    y: number;
+  }>;
+  deceleration?: number;
+}>;
+export type DecayAnimationConfigSingle = Readonly<Omit<AnimationConfig, keyof {
+  velocity: number;
+  deceleration?: number;
+}> & {
+  velocity: number;
+  deceleration?: number;
+}>;
+declare class DecayAnimation extends Animation {
+  constructor(config: DecayAnimationConfigSingle);
+  start(fromValue: number, onUpdate: (value: number) => void, onEnd: null | undefined | EndCallback, previousAnimation: null | undefined | Animation, animatedValue: AnimatedValue): void;
+  onUpdate(): void;
+  stop(): void;
+}
+export default DecayAnimation;

package/types_generated/Libraries/Animated/animations/SpringAnimation.d.ts

@@ -0,0 +1,130 @@
+/**
+ * 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<<3dda2d155d27c59b481c3344b24c8c00>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Animated/animations/SpringAnimation.js
+ */
+
+import type AnimatedInterpolation from "../nodes/AnimatedInterpolation";
+import type AnimatedValue from "../nodes/AnimatedValue";
+import type AnimatedValueXY from "../nodes/AnimatedValueXY";
+import type { AnimationConfig, EndCallback } from "./Animation";
+import AnimatedColor from "../nodes/AnimatedColor";
+import Animation from "./Animation";
+export type SpringAnimationConfig = Readonly<Omit<AnimationConfig, keyof {
+  toValue: number | AnimatedValue | {
+    x: number;
+    y: number;
+  } | AnimatedValueXY | {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+  } | AnimatedColor | AnimatedInterpolation<number>;
+  overshootClamping?: boolean;
+  restDisplacementThreshold?: number;
+  restSpeedThreshold?: number;
+  velocity?: number | Readonly<{
+    x: number;
+    y: number;
+  }>;
+  bounciness?: number;
+  speed?: number;
+  tension?: number;
+  friction?: number;
+  stiffness?: number;
+  damping?: number;
+  mass?: number;
+  delay?: number;
+}> & {
+  toValue: number | AnimatedValue | {
+    x: number;
+    y: number;
+  } | AnimatedValueXY | {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+  } | AnimatedColor | AnimatedInterpolation<number>;
+  overshootClamping?: boolean;
+  restDisplacementThreshold?: number;
+  restSpeedThreshold?: number;
+  velocity?: number | Readonly<{
+    x: number;
+    y: number;
+  }>;
+  bounciness?: number;
+  speed?: number;
+  tension?: number;
+  friction?: number;
+  stiffness?: number;
+  damping?: number;
+  mass?: number;
+  delay?: number;
+}>;
+export type SpringAnimationConfigSingle = Readonly<Omit<AnimationConfig, keyof {
+  toValue: number;
+  overshootClamping?: boolean;
+  restDisplacementThreshold?: number;
+  restSpeedThreshold?: number;
+  velocity?: number;
+  bounciness?: number;
+  speed?: number;
+  tension?: number;
+  friction?: number;
+  stiffness?: number;
+  damping?: number;
+  mass?: number;
+  delay?: number;
+}> & {
+  toValue: number;
+  overshootClamping?: boolean;
+  restDisplacementThreshold?: number;
+  restSpeedThreshold?: number;
+  velocity?: number;
+  bounciness?: number;
+  speed?: number;
+  tension?: number;
+  friction?: number;
+  stiffness?: number;
+  damping?: number;
+  mass?: number;
+  delay?: number;
+}>;
+declare type SpringAnimationInternalState = symbol & {
+  __SpringAnimationInternalState__: string;
+};
+declare class SpringAnimation extends Animation {
+  constructor(config: SpringAnimationConfigSingle);
+  start(fromValue: number, onUpdate: (value: number) => void, onEnd: null | undefined | EndCallback, previousAnimation: null | undefined | Animation, animatedValue: AnimatedValue): void;
+  getInternalState(): SpringAnimationInternalState;
+  /**
+   * This spring model is based off of a damped harmonic oscillator
+   * (https://en.wikipedia.org/wiki/Harmonic_oscillator#Damped_harmonic_oscillator).
+   *
+   * We use the closed form of the second order differential equation:
+   *
+   * x'' + (2ζ⍵_0)x' + ⍵^2x = 0
+   *
+   * where
+   *    ⍵_0 = √(k / m) (undamped angular frequency of the oscillator),
+   *    ζ = c / 2√mk (damping ratio),
+   *    c = damping constant
+   *    k = stiffness
+   *    m = mass
+   *
+   * The derivation of the closed form is described in detail here:
+   * http://planetmath.org/sites/default/files/texpdf/39745.pdf
+   *
+   * This algorithm happens to match the algorithm used by CASpringAnimation,
+   * a QuartzCore (iOS) API that creates spring animations.
+   */
+  onUpdate(): void;
+  stop(): void;
+}
+export default SpringAnimation;

package/types_generated/Libraries/Animated/animations/TimingAnimation.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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<<39dac0e67f437705c8562476e4ff745a>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Animated/animations/TimingAnimation.js
+ */
+
+import type { RgbaValue } from "../nodes/AnimatedColor";
+import type AnimatedInterpolation from "../nodes/AnimatedInterpolation";
+import type AnimatedValue from "../nodes/AnimatedValue";
+import type AnimatedValueXY from "../nodes/AnimatedValueXY";
+import type { AnimationConfig, EndCallback } from "./Animation";
+import AnimatedColor from "../nodes/AnimatedColor";
+import Animation from "./Animation";
+export type TimingAnimationConfig = Readonly<Omit<AnimationConfig, keyof {
+  toValue: number | AnimatedValue | Readonly<{
+    x: number;
+    y: number;
+  }> | AnimatedValueXY | RgbaValue | AnimatedColor | AnimatedInterpolation<number>;
+  easing?: (value: number) => number;
+  duration?: number;
+  delay?: number;
+}> & {
+  toValue: number | AnimatedValue | Readonly<{
+    x: number;
+    y: number;
+  }> | AnimatedValueXY | RgbaValue | AnimatedColor | AnimatedInterpolation<number>;
+  easing?: (value: number) => number;
+  duration?: number;
+  delay?: number;
+}>;
+export type TimingAnimationConfigSingle = Readonly<Omit<AnimationConfig, keyof {
+  toValue: number;
+  easing?: (value: number) => number;
+  duration?: number;
+  delay?: number;
+}> & {
+  toValue: number;
+  easing?: (value: number) => number;
+  duration?: number;
+  delay?: number;
+}>;
+declare class TimingAnimation extends Animation {
+  constructor(config: TimingAnimationConfigSingle);
+  start(fromValue: number, onUpdate: (value: number) => void, onEnd: null | undefined | EndCallback, previousAnimation: null | undefined | Animation, animatedValue: AnimatedValue): void;
+  onUpdate(): void;
+  stop(): void;
+}
+export default TimingAnimation;

package/types_generated/Libraries/Animated/components/AnimatedFlatList.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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<<8c632390670213fd78073b0243c08f19>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Animated/components/AnimatedFlatList.js
+ */
+
+import type { AnimatedProps } from "../createAnimatedComponent";
+import FlatList, { type FlatListProps } from "../../Lists/FlatList";
+import * as React from "react";
+declare const $$AnimatedFlatList: <ItemT = any>(props: Omit<AnimatedProps<FlatListProps<ItemT>>, keyof {
+  ref?: React.Ref<FlatList<ItemT>>;
+}> & {
+  ref?: React.Ref<FlatList<ItemT>>;
+}) => React.ReactNode;
+declare type $$AnimatedFlatList = typeof $$AnimatedFlatList;
+export default $$AnimatedFlatList;

package/types_generated/Libraries/Animated/components/AnimatedImage.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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<<7cc2bab4b885419bb0820a8e69e63b8b>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Animated/components/AnimatedImage.js
+ */
+
+import type { AnimatedComponentType } from "../createAnimatedComponent";
+import Image from "../../Image/Image";
+import * as React from "react";
+declare const $$AnimatedImage: AnimatedComponentType<React.JSX.LibraryManagedAttributes<typeof Image, React.ComponentProps<typeof Image>>, React.ComponentRef<typeof Image>>;
+declare type $$AnimatedImage = typeof $$AnimatedImage;
+export default $$AnimatedImage;

package/types_generated/Libraries/Animated/components/AnimatedScrollView.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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<<ccca8e1da0d30d12a67984ccadfcc654>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Animated/components/AnimatedScrollView.js
+ */
+
+import type { AnimatedComponentType } from "../createAnimatedComponent";
+import ScrollView, { type ScrollViewProps } from "../../Components/ScrollView/ScrollView";
+import * as React from "react";
+type AnimatedScrollViewInstance = React.ComponentRef<typeof ScrollView>;
+declare const AnimatedScrollView: AnimatedComponentType<ScrollViewProps, AnimatedScrollViewInstance>;
+/**
+ * @see https://github.com/react/react-native/commit/b8c8562
+ */
+declare const $$AnimatedScrollView: typeof AnimatedScrollView;
+declare type $$AnimatedScrollView = typeof $$AnimatedScrollView;
+export default $$AnimatedScrollView;

package/types_generated/Libraries/Animated/components/AnimatedSectionList.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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<<a9fe4d54975316cfdb1f3e9503be8088>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Animated/components/AnimatedSectionList.js
+ */
+
+import type { AnimatedProps } from "../createAnimatedComponent";
+import SectionList, { type SectionListProps } from "../../Lists/SectionList";
+import * as React from "react";
+declare const $$AnimatedSectionList: <ItemT = any, SectionT = any>(props: Omit<AnimatedProps<SectionListProps<ItemT, SectionT>>, keyof {
+  ref?: React.Ref<SectionList<ItemT, SectionT>>;
+}> & {
+  ref?: React.Ref<SectionList<ItemT, SectionT>>;
+}) => React.ReactNode;
+declare type $$AnimatedSectionList = typeof $$AnimatedSectionList;
+export default $$AnimatedSectionList;