react-native-tvos 0.87.1-0 → 0.87.1-1

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

@@ -0,0 +1,232 @@
+/**
+ * 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<<deb4750b606ad5eeb96001b63b6e5089>>
+ *
+ * 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 = {
+  /**
+   * Animations are started by calling start() on your animation.
+   * start() takes a completion callback that will be called when the
+   * animation is done or when the animation is done because stop() was
+   * called on it before it could finish.
+   *
+   * @param callback - Optional function that will be called
+   *      after the animation finished running normally or when the animation
+   *      is done because stop() was called on it before it could finish
+   *
+   * @example
+   *   Animated.timing({}).start(({ finished }) => {
+   *    // completion callback
+   *   });
+   */
+  start: (callback?: EndCallback | undefined, isLooping?: boolean) => void;
+  /**
+   * Stops any running animation.
+   */
+  stop: () => void;
+  /**
+   * Stops any running animation and resets the value to its original.
+   */
+  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 | undefined;
+};
+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 | undefined;
+};
+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>) => (...args: Array<any>) => void;
+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;
+  /**
+   * Animates a value from an initial velocity to zero based on a decay
+   * coefficient.
+   */
+  decay: typeof decayImpl;
+  /**
+   * Animates a value along a timed easing curve.  The `Easing` module has tons
+   * of pre-defined curves, or you can use your own function.
+   */
+  timing: typeof timingImpl;
+  /**
+   * Spring animation based on Rebound and Origami.  Tracks velocity state to
+   * create fluid motions as the `toValue` updates, and can be chained together.
+   */
+  spring: typeof springImpl;
+  /**
+   * Creates a new Animated value composed from two Animated values added
+   * together.
+   */
+  add: typeof addImpl;
+  /**
+   * Creates a new Animated value composed by subtracting the second Animated
+   * value from the first Animated value.
+   */
+  subtract: typeof subtractImpl;
+  /**
+   * Creates a new Animated value composed by dividing the first Animated
+   * value by the second Animated value.
+   */
+  divide: typeof divideImpl;
+  /**
+   * Creates a new Animated value composed from two Animated values multiplied
+   * together.
+   */
+  multiply: typeof multiplyImpl;
+  /**
+   * Creates a new Animated value that is the (non-negative) modulo of the
+   * provided Animated value
+   */
+  modulo: typeof moduloImpl;
+  /**
+   * Create a new Animated value that is limited between 2 values. It uses the
+   * difference between the last value so even if the value is far from the bounds
+   * it will start changing when the value starts getting closer again.
+   * (`value = clamp(value + diff, min, max)`).
+   *
+   * This is useful with scroll events, for example, to show the navbar when
+   * scrolling up and to hide it when scrolling down.
+   */
+  diffClamp: typeof diffClampImpl;
+  /**
+   * Starts an animation after the given delay.
+   */
+  delay: typeof delayImpl;
+  /**
+   * Starts an array of animations in order, waiting for each to complete
+   * before starting the next.  If the current running animation is stopped, no
+   * following animations will be started.
+   */
+  sequence: typeof sequenceImpl;
+  /**
+   * Starts an array of animations all at the same time.  By default, if one
+   * of the animations is stopped, they will all be stopped.  You can override
+   * this with the `stopTogether` flag.
+   */
+  parallel: typeof parallelImpl;
+  /**
+   * Array of animations may run in parallel (overlap), but are started in
+   * sequence with successive delays.  Nice for doing trailing effects.
+   */
+  stagger: typeof staggerImpl;
+  /**
+   * Loops a given animation continuously, so that each time it reaches the end,
+   * it resets and begins again from the start. Can specify number of times to
+   * loop using the key 'iterations' in the config. Will loop without blocking
+   * the UI thread if the child animation is set to 'useNativeDriver'.
+   */
+  loop: typeof loopImpl;
+  /**
+   *  Takes an array of mappings and extracts values from each arg accordingly,
+   *  then calls `setValue` on the mapped outputs.  e.g.
+   *
+   *```javascript
+   *  onScroll={Animated.event(
+   *    [{nativeEvent: {contentOffset: {x: this._scrollX}}}]
+   *    {listener},          // Optional async listener
+   *  )
+   *  ...
+   *  onPanResponderMove: Animated.event([
+   *    null,                // raw event arg ignored
+   *    {dx: this._panX},    // gestureState arg
+   *  ]),
+   *```
+   */
+  event: typeof eventImpl;
+  /**
+   * Make any React component Animatable.  Used to create `Animated.View`, etc.
+   */
+  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,172 @@
+/**
+ * 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<<35d2a2219df674cbee4489365c08a539>>
+ *
+ * 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;
+/**
+ * Implements common easing functions for use with `Animated.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
+ *
+ * @see https://reactnative.dev/docs/easing
+ */
+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<<75b3486fbb3158cfb8bcab03e5ad45f0>>
+ *
+ * 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 | undefined;
+  offset?: number | undefined;
+};
+export type EndCallback = (result: EndResult) => void;
+export type AnimationConfig = Readonly<{
+  isInteraction?: boolean | undefined;
+  useNativeDriver: boolean;
+  platformConfig?: PlatformConfig | undefined;
+  onComplete?: EndCallback | undefined;
+  iterations?: number | undefined;
+  isLooping?: boolean | undefined;
+  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<<87d33b318553204c4cfbb4837dfeff3b>>
+ *
+ * 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 | undefined;
+}> & {
+  velocity: number | Readonly<{
+    x: number;
+    y: number;
+  }>;
+  deceleration?: number | undefined;
+}>;
+export type DecayAnimationConfigSingle = Readonly<Omit<AnimationConfig, keyof {
+  velocity: number;
+  deceleration?: number | undefined;
+}> & {
+  velocity: number;
+  deceleration?: number | undefined;
+}>;
+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<<8d1ddb1f144198187d21b409ceca53cd>>
+ *
+ * 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 | undefined;
+  restDisplacementThreshold?: number | undefined;
+  restSpeedThreshold?: number | undefined;
+  velocity?: number | Readonly<{
+    x: number;
+    y: number;
+  }> | undefined;
+  bounciness?: number | undefined;
+  speed?: number | undefined;
+  tension?: number | undefined;
+  friction?: number | undefined;
+  stiffness?: number | undefined;
+  damping?: number | undefined;
+  mass?: number | undefined;
+  delay?: number | undefined;
+}> & {
+  toValue: number | AnimatedValue | {
+    x: number;
+    y: number;
+  } | AnimatedValueXY | {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+  } | AnimatedColor | AnimatedInterpolation<number>;
+  overshootClamping?: boolean | undefined;
+  restDisplacementThreshold?: number | undefined;
+  restSpeedThreshold?: number | undefined;
+  velocity?: number | Readonly<{
+    x: number;
+    y: number;
+  }> | undefined;
+  bounciness?: number | undefined;
+  speed?: number | undefined;
+  tension?: number | undefined;
+  friction?: number | undefined;
+  stiffness?: number | undefined;
+  damping?: number | undefined;
+  mass?: number | undefined;
+  delay?: number | undefined;
+}>;
+export type SpringAnimationConfigSingle = Readonly<Omit<AnimationConfig, keyof {
+  toValue: number;
+  overshootClamping?: boolean | undefined;
+  restDisplacementThreshold?: number | undefined;
+  restSpeedThreshold?: number | undefined;
+  velocity?: number | undefined;
+  bounciness?: number | undefined;
+  speed?: number | undefined;
+  tension?: number | undefined;
+  friction?: number | undefined;
+  stiffness?: number | undefined;
+  damping?: number | undefined;
+  mass?: number | undefined;
+  delay?: number | undefined;
+}> & {
+  toValue: number;
+  overshootClamping?: boolean | undefined;
+  restDisplacementThreshold?: number | undefined;
+  restSpeedThreshold?: number | undefined;
+  velocity?: number | undefined;
+  bounciness?: number | undefined;
+  speed?: number | undefined;
+  tension?: number | undefined;
+  friction?: number | undefined;
+  stiffness?: number | undefined;
+  damping?: number | undefined;
+  mass?: number | undefined;
+  delay?: number | undefined;
+}>;
+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<<38370d2065d999c7ba0074e6b74c9f8f>>
+ *
+ * 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) | undefined;
+  duration?: number | undefined;
+  delay?: number | undefined;
+}> & {
+  toValue: number | AnimatedValue | Readonly<{
+    x: number;
+    y: number;
+  }> | AnimatedValueXY | RgbaValue | AnimatedColor | AnimatedInterpolation<number>;
+  easing?: ((value: number) => number) | undefined;
+  duration?: number | undefined;
+  delay?: number | undefined;
+}>;
+export type TimingAnimationConfigSingle = Readonly<Omit<AnimationConfig, keyof {
+  toValue: number;
+  easing?: ((value: number) => number) | undefined;
+  duration?: number | undefined;
+  delay?: number | undefined;
+}> & {
+  toValue: number;
+  easing?: ((value: number) => number) | undefined;
+  duration?: number | undefined;
+  delay?: number | undefined;
+}>;
+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;