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

package/scripts/spm/spm-utils.js

@@ -14,6 +14,67 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
+// The package and product names React Native's own generated manifests use. A
+// dependency whose Swift name lands on one of them surfaces as a duplicate-name
+// error from inside SPM's resolution, far from the react-native.config.js that
+// caused it, so the autolinker rejects the collision up front instead.
+//
+// These cover the emitters in this directory and the collision guard. Adding a
+// React Native SPM product also touches, depending on what the product is:
+//   - scripts/codegen/templates/Package.swift.spm-template — if the per-app
+//     codegen package must depend on it (a static Swift file, patched by
+//     string replacement, not generated from these constants)
+//   - flavored-frameworks.js INVARIANT_BINARY_TARGETS — if it is
+//     xcframework-backed
+//   - download-spm-artifacts.js REQUIRED_ARTIFACTS — if it ships as its own
+//     downloadable artifact (that list names ARTIFACTS, which overlap with
+//     product names without being the same set)
+const REACT_NATIVE_PACKAGE_NAME /*: string */ = 'ReactNative';
+const REACT_CODEGEN_PACKAGE_NAME /*: string */ = 'React-GeneratedCode';
+// The autolinking aggregator package, whose single product shares its name.
+const AUTOLINKED_PACKAGE_NAME /*: string */ = 'Autolinked';
+// React Native's products by KIND, so no consumer has to infer the kind from a
+// position in a flat list. The umbrella is a Clang target over the staged
+// headers that re-exports the pure-RN namespaces; the rest are each backed by
+// an xcframework of the same name.
+const REACT_NATIVE_UMBRELLA_PRODUCT /*: string */ = 'ReactHeaders';
+const REACT_NATIVE_HEADERS_PRODUCT /*: string */ = 'ReactNativeHeaders';
+const REACT_NATIVE_DEPENDENCIES_HEADERS_PRODUCT /*: string */ =
+  'ReactNativeDependenciesHeaders';
+const REACT_NATIVE_XCFRAMEWORK_PRODUCTS /*: ReadonlyArray<string> */ =
+  Object.freeze([
+    REACT_NATIVE_HEADERS_PRODUCT,
+    REACT_NATIVE_DEPENDENCIES_HEADERS_PRODUCT,
+  ]);
+// Derived, so a new product cannot be added without choosing a kind above.
+const REACT_NATIVE_PRODUCTS /*: ReadonlyArray<string> */ = Object.freeze([
+  REACT_NATIVE_UMBRELLA_PRODUCT,
+  ...REACT_NATIVE_XCFRAMEWORK_PRODUCTS,
+]);
+// The codegen package product every autolinked target depends on for the app's
+// generated headers.
+const REACT_CODEGEN_PRODUCTS /*: ReadonlyArray<string> */ = Object.freeze([
+  'ReactAppHeaders',
+]);
+// The codegen package products the APP target links, declared by the static
+// template rather than by any emitter here.
+const REACT_CODEGEN_APP_PRODUCTS /*: ReadonlyArray<string> */ = Object.freeze([
+  'ReactCodegen',
+  'ReactAppDependencyProvider',
+]);
+const REACT_HEADERS_TARGET_DIR /*: string */ = 'ReactHeadersTarget';
+// Target names only have to be unique within their own package, so
+// REACT_HEADERS_TARGET_DIR is deliberately absent: a dependency named after it
+// collides with nothing.
+const RESERVED_SWIFT_NAMES /*: ReadonlyArray<string> */ = Object.freeze([
+  REACT_NATIVE_PACKAGE_NAME,
+  REACT_CODEGEN_PACKAGE_NAME,
+  AUTOLINKED_PACKAGE_NAME,
+  ...REACT_NATIVE_PRODUCTS,
+  ...REACT_CODEGEN_PRODUCTS,
+  ...REACT_CODEGEN_APP_PRODUCTS,
+]);
+
 /**
  * Creates a logger trio {log, warn, die} that prefixes messages with [name].
  *   log  – green prefix, writes to stdout
@@ -582,10 +643,10 @@ function installSpmCodegenTemplate(
   if (remote != null) {
     content = content
       .replace(
-        '.package(name: "ReactNative", path: "../../xcframeworks"),',
+        `.package(name: "${REACT_NATIVE_PACKAGE_NAME}", path: "../../xcframeworks"),`,
         `.package(url: "${remote.url}", exact: "${remote.version}"),`,
       )
-      .split('package: "ReactNative")')
+      .split(`package: "${REACT_NATIVE_PACKAGE_NAME}")`)
       .join(`package: "${remote.identity}")`);
   }
   fs.writeFileSync(codegenPkgSwift, content, 'utf8');
@@ -624,7 +685,59 @@ function runCodegenAndInstallTemplate(
   }
 }
 
+// ---------------------------------------------------------------------------
+// Autolinking-plugin script phases — the shared validation rules. Two gates
+// apply them with different POLICIES (invokePlugins throws, the injector's
+// sidecar reader skips the entry), so only the rules live here. See
+// __doc__/spm-autolinking-plugins.md for the reasoning.
+// ---------------------------------------------------------------------------
+
+// `@` and `/` are admitted so a package can use its own scoped npm name
+// (`@expo/log-box`). `:` is not: the id is hashed into the UUID seed as
+// `plugin:<id>`, and keeping the separator out of the id keeps that seed
+// unambiguous.
+const SCRIPT_PHASE_ID_PATTERN = /^[@A-Za-z0-9_./-]+$/;
+
+// `ledger.__proto__ = uuid` sets the prototype instead of an own property, so a
+// phase with one of these ids would look recorded, vanish through
+// JSON.stringify, and never be removable by `deinit`.
+const RESERVED_SCRIPT_PHASE_IDS = new Set([
+  '__proto__',
+  'constructor',
+  'prototype',
+]);
+
+function isValidScriptPhaseId(value /*: unknown */) /*: boolean */ {
+  return (
+    typeof value === 'string' &&
+    SCRIPT_PHASE_ID_PATTERN.test(value) &&
+    !RESERVED_SCRIPT_PHASE_IDS.has(value)
+  );
+}
+
+/**
+ * The name reaches the project file twice: verbatim in the escaped `name` field
+ * Xcode displays, and normalized (spm-pbxproj's commentSafe) in the cosmetic
+ * `/* … *​/` comments. Both are safe for any single-line string, so the only
+ * thing left to refuse is a line break — which no Xcode phase display name can
+ * carry anyway.
+ */
+function isValidScriptPhaseName(value /*: unknown */) /*: boolean */ {
+  return typeof value === 'string' && value.length > 0 && !/[\r\n]/.test(value);
+}
+
 module.exports = {
+  REACT_NATIVE_PACKAGE_NAME,
+  REACT_CODEGEN_PACKAGE_NAME,
+  AUTOLINKED_PACKAGE_NAME,
+  REACT_NATIVE_UMBRELLA_PRODUCT,
+  REACT_NATIVE_HEADERS_PRODUCT,
+  REACT_NATIVE_XCFRAMEWORK_PRODUCTS,
+  REACT_NATIVE_PRODUCTS,
+  REACT_CODEGEN_PRODUCTS,
+  REACT_CODEGEN_APP_PRODUCTS,
+  REACT_HEADERS_TARGET_DIR,
+  RESERVED_SWIFT_NAMES,
   makeLogger,
   displayPath,
   sharedCacheDir,
@@ -641,5 +754,7 @@ module.exports = {
   RemoteVersionError,
   installSpmCodegenTemplate,
   runCodegenAndInstallTemplate,
+  isValidScriptPhaseId,
+  isValidScriptPhaseName,
   SCAFFOLDER_MARKER,
 };

package/sdks/.hermesv1version

@@ -1 +1 @@
-hermes-v250829098.0.16
+hermes-v250829098.0.17

package/sdks/hermes-engine/version.properties

@@ -1 +1 @@
-HERMES_VERSION_NAME=250829098.0.16
+HERMES_VERSION_NAME=250829098.0.17

package/types/public/ReactNativeTVTypes.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import type { View, ScrollViewProps, HostComponent, EventSubscription, TVParallaxProperties } from 'react-native';
+import type { View, ScrollViewProps, HostComponent, EventSubscription, TVParallaxProperties, FocusEvent, BlurEvent } from 'react-native';
 
 declare module 'react-native' {
   export type FocusDestination = null | number | React.Component<any, any> | React.ComponentClass<any>;
@@ -19,6 +19,34 @@ declare module 'react-native' {
      * @platform tv
      */
     scrollAnimationEnabled?: boolean | undefined;
+
+    /**
+     * Duration in milliseconds of the animated scroll that runs when focus moves to
+     * another item. Applies to the snap scroll (`snapToAlignment="item"` with
+     * per-item `scrollSnapAlign`/`scrollSnapOffset` markers) and to animated
+     * `scrollTo` commands; other focus scrolls are instant. When unset or <= 0, the platform default (~250ms) is used.
+     * On tvOS the focus engine owns this animation and the prop has no effect.
+     *
+     * @platform android
+     */
+    scrollAnimationDuration?: number | undefined;
+
+    /**
+     * Easing curve of that animation, either a CSS easing keyword or explicit
+     * cubic-bezier control points `[x1, y1, x2, y2]`. When unset, the platform
+     * default curve (`AccelerateDecelerateInterpolator`) is used.
+     * On tvOS the focus engine owns this animation and the prop has no effect.
+     *
+     * @platform android
+     */
+    scrollAnimationEasing?:
+      | 'linear'
+      | 'ease'
+      | 'ease-in'
+      | 'ease-out'
+      | 'ease-in-out'
+      | [number, number, number, number]
+      | undefined;
   }
 
   interface ViewProps {
@@ -151,6 +179,17 @@ declare module 'react-native' {
      * @deprecated Don't use it, no longer necessary.
      */
     safePadding?: 'both' | 'vertical' | 'horizontal' | null | undefined;
+    /**
+     * Fires once when focus enters this focus guide's subtree from outside.
+     * Unlike `onFocus`, which bubbles and fires for every descendant, this
+     * does not fire again when focus moves between descendants.
+     */
+    onFocusEnter?: ((event: FocusEvent) => void) | undefined;
+    /**
+     * Fires once when focus leaves this focus guide's subtree entirely. Does
+     * not fire when focus moves between descendants. Pairs with `onFocusEnter`.
+     */
+    onFocusLeave?: ((event: BlurEvent) => void) | undefined;
   }
 
   export type FocusGuideMethods = {

package/types_generated/Libraries/ActionSheetIOS/ActionSheetIOS.d.ts

@@ -0,0 +1,96 @@
+/**
+ * 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<<c9df6a2ec502499b961157efa0dd4654>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/ActionSheetIOS/ActionSheetIOS.js
+ */
+
+import type { ProcessedColorValue } from "../StyleSheet/processColor";
+import type { ColorValue } from "../StyleSheet/StyleSheet";
+export type ActionSheetIOSOptions = Readonly<{
+  title?: string | undefined;
+  message?: string | undefined;
+  options: Array<string>;
+  destructiveButtonIndex?: (number | undefined) | (Array<number> | undefined) | undefined;
+  cancelButtonIndex?: number | undefined;
+  anchor?: number | undefined;
+  tintColor?: ColorValue | ProcessedColorValue | undefined;
+  cancelButtonTintColor?: ColorValue | ProcessedColorValue | undefined;
+  disabledButtonTintColor?: ColorValue | ProcessedColorValue | undefined;
+  userInterfaceStyle?: string | undefined;
+  disabledButtonIndices?: Array<number> | undefined;
+}>;
+export type ShareActionSheetIOSOptions = Readonly<{
+  message?: string | undefined;
+  url?: string | undefined;
+  subject?: string | undefined;
+  anchor?: number | undefined;
+  tintColor?: number | undefined;
+  cancelButtonTintColor?: number | undefined;
+  disabledButtonTintColor?: number | undefined;
+  /**
+   * The activities to exclude from the ActionSheet.
+   * For example: ['com.apple.UIKit.activity.PostToTwitter']
+   */
+  excludedActivityTypes?: Array<string> | undefined;
+  userInterfaceStyle?: string | undefined;
+}>;
+export type ShareActionSheetError = Readonly<{
+  domain: string;
+  code: string;
+  userInfo?: Object | undefined;
+  message: string;
+}>;
+declare const ActionSheetIOS: {
+  /**
+   * Display an iOS action sheet.
+   *
+   * The `options` object must contain one or more of:
+   *
+   * - `options` (array of strings) - a list of button titles (required)
+   * - `cancelButtonIndex` (int) - index of cancel button in `options`
+   * - `destructiveButtonIndex` (int or array of ints) - indices of destructive buttons in `options`
+   * - `title` (string) - a title to show above the action sheet
+   * - `message` (string) - a message to show below the title
+   * - `disabledButtonIndices` (array of numbers) - a list of button indices which should be disabled
+   *
+   * The `callback` function receives the zero-based index of the selected
+   * item.
+   */
+  showActionSheetWithOptions(options: ActionSheetIOSOptions, callback: (buttonIndex: number) => void): void;
+  /**
+   * Display the iOS share sheet. The `options` object should contain one or
+   * both of `message` and `url` and can additionally have a `subject` or
+   * `excludedActivityTypes`:
+   *
+   * - `url` (string) - a URL to share
+   * - `message` (string) - a message to share
+   * - `subject` (string) - a subject for the message
+   * - `excludedActivityTypes` (array) - the activities to exclude from the ActionSheet
+   * - `tintColor` (color) - tint color of the buttons
+   *
+   * The `failureCallback` function receives an error object. The
+   * `successCallback` function receives a boolean indicating success and a
+   * string describing the sharing method used.
+   */
+  showShareActionSheetWithOptions(options: ShareActionSheetIOSOptions, failureCallback: Function | ((error: ShareActionSheetError) => void), successCallback: Function | ((success: boolean, method: null | undefined | string) => void)): void;
+  /**
+   * Dismiss the most upper action sheet currently presented. Displays a
+   * warning if no action sheet is present.
+   */
+  dismissActionSheet: () => void;
+};
+/**
+ * Displays native iOS action sheets and share sheets.
+ *
+ * @see https://reactnative.dev/docs/actionsheetios
+ * @platform ios
+ */
+declare const $$ActionSheetIOS: typeof ActionSheetIOS;
+declare type $$ActionSheetIOS = typeof $$ActionSheetIOS;
+export default $$ActionSheetIOS;

package/types_generated/Libraries/Alert/Alert.d.ts

@@ -0,0 +1,92 @@
+/**
+ * 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<<91c4fbdaf5ce348ce30173be24dc7367>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Alert/Alert.js
+ */
+
+/**
+ * @platform ios
+ */
+export type AlertType = "default" | "plain-text" | "secure-text" | "login-password";
+/**
+ * @platform ios
+ */
+export type AlertButtonStyle = "default" | "cancel" | "destructive";
+export type AlertButton = {
+  text?: string | undefined;
+  onPress?: (((value?: string) => any) | undefined) | (Function | undefined) | undefined;
+  isPreferred?: boolean | undefined;
+  style?: AlertButtonStyle | undefined;
+};
+export type AlertButtons = Array<AlertButton>;
+export type AlertOptions = {
+  /** @platform android */
+  cancelable?: boolean | undefined;
+  userInterfaceStyle?: "unspecified" | "light" | "dark" | undefined;
+  /** @platform android */
+  onDismiss?: (() => void) | undefined;
+};
+/**
+ * Launches an alert dialog with the specified title and message.
+ *
+ * Optionally provide a list of buttons. Tapping any button will fire the
+ * respective onPress callback and dismiss the alert. By default, the only
+ * button will be an 'OK' button.
+ *
+ * This is an API that works both on iOS and Android and can show static
+ * alerts. On iOS, you can show an alert that prompts the user to enter
+ * some information.
+ *
+ * ## iOS
+ *
+ * On iOS you can specify any number of buttons. Each button can optionally
+ * specify a style, which is one of 'default', 'cancel' or 'destructive'.
+ *
+ * ## Android
+ *
+ * On Android at most three buttons can be specified. Android has a concept
+ * of a neutral, negative and a positive button:
+ *
+ *   - If you specify one button, it will be the 'positive' one (such as 'OK')
+ *   - Two buttons mean 'negative', 'positive' (such as 'Cancel', 'OK')
+ *   - Three buttons mean 'neutral', 'negative', 'positive' (such as 'Later', 'Cancel', 'OK')
+ *
+ * Example:
+ *
+ * ```tsx
+ * // Works on both iOS and Android
+ * Alert.alert(
+ *   'Alert Title',
+ *   'My Alert Msg',
+ *   [
+ *     {text: 'Ask me later', onPress: () => console.log('Ask me later pressed')},
+ *     {text: 'Cancel', onPress: () => console.log('Cancel Pressed'), style: 'cancel'},
+ *     {text: 'OK', onPress: () => console.log('OK Pressed')},
+ *   ]
+ * )
+ * ```
+ *
+ * @see https://reactnative.dev/docs/alert
+ */
+declare class Alert {
+  /**
+   * Display an alert dialog with the specified title, message, and buttons.
+   * On Android, at most three buttons can be specified. On iOS, any number of
+   * buttons can be used.
+   */
+  static alert(title: null | undefined | string, message?: null | undefined | string, buttons?: AlertButtons, options?: AlertOptions): void;
+  /**
+   * Create and display a prompt to enter text. Accepts a title, message,
+   * callback or buttons, input type, default value, keyboard type, and options.
+   *
+   * @platform ios
+   */
+  static prompt(title: null | undefined | string, message?: null | undefined | string, callbackOrButtons?: null | undefined | (((text: string) => void) | AlertButtons), type?: null | undefined | AlertType, defaultValue?: string, keyboardType?: string, options?: AlertOptions): void;
+}
+export default Alert;

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

@@ -0,0 +1,14 @@
+/**
+ * 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<<e78458e6def7485a52e194d9d7546970>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Animated/Animated.js.flow
+ */
+
+export * as default from "./AnimatedExports";
+export type { CompositeAnimation, Numeric } from "./AnimatedImplementation";

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

@@ -0,0 +1,30 @@
+/**
+ * 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<<156c6b4bd89b4931acd61ed1d1291a7e>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Animated/AnimatedEvent.js
+ */
+
+import type { NativeSyntheticEvent } from "../Types/CoreEventTypes";
+import type { PlatformConfig } from "./AnimatedPlatformConfig";
+import AnimatedValue from "./nodes/AnimatedValue";
+import AnimatedValueXY from "./nodes/AnimatedValueXY";
+export type Mapping = {
+  [key: string]: Mapping;
+} | AnimatedValue | AnimatedValueXY;
+export type EventConfig<T> = {
+  listener?: (($$PARAM_0$$: NativeSyntheticEvent<T>) => unknown) | undefined;
+  useNativeDriver: boolean;
+  platformConfig?: PlatformConfig | undefined;
+};
+export declare function attachNativeEventImpl(viewRef: any, eventName: string, argMapping: ReadonlyArray<null | undefined | Mapping>, platformConfig: null | undefined | PlatformConfig): {
+  detach: () => void;
+};
+export declare class AnimatedEvent {
+  constructor(argMapping: ReadonlyArray<null | undefined | Mapping>, config: EventConfig<any>);
+}

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

@@ -0,0 +1,191 @@
+/**
+ * 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<<8cf8d614df17c64a2e6e3616785cbc2e>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Animated/AnimatedExports.js.flow
+ */
+
+import AnimatedImplementation from "./AnimatedImplementation";
+export type { CompositeAnimation, Numeric } from "./AnimatedImplementation";
+export type { DecayAnimationConfig } from "./animations/DecayAnimation";
+export type { SpringAnimationConfig } from "./animations/SpringAnimation";
+export type { TimingAnimationConfig } from "./animations/TimingAnimation";
+export { default as FlatList } from "./components/AnimatedFlatList";
+export { default as Image } from "./components/AnimatedImage";
+export { default as ScrollView } from "./components/AnimatedScrollView";
+export { default as SectionList } from "./components/AnimatedSectionList";
+export { default as Text } from "./components/AnimatedText";
+export { default as View } from "./components/AnimatedView";
+export { default as Color } from "./nodes/AnimatedColor";
+export { AnimatedEvent as Event } from "./AnimatedEvent";
+export { default as Interpolation } from "./nodes/AnimatedInterpolation";
+export { default as Node } from "./nodes/AnimatedNode";
+export { default as Value } from "./nodes/AnimatedValue";
+export { default as ValueXY } from "./nodes/AnimatedValueXY";
+/** @deprecated Use Animated.Interpolation instead */
+export type { default as AnimatedInterpolation } from "./nodes/AnimatedInterpolation";
+/** @deprecated Use Animated.Color instead */
+export type { default as AnimatedColor } from "./nodes/AnimatedColor";
+export type { AnimatedValueConfig as AnimatedConfig } from "./nodes/AnimatedValue";
+export type { default as AnimatedNode } from "./nodes/AnimatedNode";
+export type { default as AnimatedAddition } from "./nodes/AnimatedAddition";
+export type { default as AnimatedDiffClamp } from "./nodes/AnimatedDiffClamp";
+export type { default as AnimatedDivision } from "./nodes/AnimatedDivision";
+export type { InterpolationConfigType as InterpolationConfig } from "./nodes/AnimatedInterpolation";
+export type { default as AnimatedModulo } from "./nodes/AnimatedModulo";
+export type { default as AnimatedMultiplication } from "./nodes/AnimatedMultiplication";
+export type { default as AnimatedSubtraction } from "./nodes/AnimatedSubtraction";
+export type { WithAnimatedValue, AnimatedProps } from "./createAnimatedComponent";
+export type { AnimatedComponentType as AnimatedComponent } from "./createAnimatedComponent";
+/**
+ * Creates a new Animated value composed from two Animated values added
+ * together.
+ *
+ * See https://reactnative.dev/docs/animated#add
+ */
+export declare const add: typeof AnimatedImplementation.add;
+export declare type add = typeof add;
+/**
+ * Imperative API to attach an animated value to an event on a view. Prefer
+ * using `Animated.event` with `useNativeDrive: true` if possible.
+ *
+ * See https://reactnative.dev/docs/animated#attachnativeevent
+ */
+export declare const attachNativeEvent: typeof AnimatedImplementation.attachNativeEvent;
+export declare type attachNativeEvent = typeof attachNativeEvent;
+/**
+ * Make any React component Animatable. Used to create `Animated.View`, etc.
+ *
+ * See https://reactnative.dev/docs/animated#createanimatedcomponent
+ */
+export declare const createAnimatedComponent: typeof AnimatedImplementation.createAnimatedComponent;
+export declare type createAnimatedComponent = typeof createAnimatedComponent;
+/**
+ * Animates a value from an initial velocity to zero based on a decay
+ * coefficient.
+ *
+ * See https://reactnative.dev/docs/animated#decay
+ */
+export declare const decay: typeof AnimatedImplementation.decay;
+export declare type decay = typeof decay;
+/**
+ * Starts an animation after the given delay.
+ *
+ * See https://reactnative.dev/docs/animated#delay
+ */
+export declare const delay: typeof AnimatedImplementation.delay;
+export declare type delay = typeof delay;
+/**
+ * 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.
+ *
+ * See https://reactnative.dev/docs/animated#diffclamp
+ */
+export declare const diffClamp: typeof AnimatedImplementation.diffClamp;
+export declare type diffClamp = typeof diffClamp;
+/**
+ * Creates a new Animated value composed by dividing the first Animated value
+ * by the second Animated value.
+ *
+ * See https://reactnative.dev/docs/animated#divide
+ */
+export declare const divide: typeof AnimatedImplementation.divide;
+export declare type divide = typeof divide;
+/**
+ * Takes an array of mappings and extracts values from each arg accordingly,
+ * then calls `setValue` on the mapped outputs.
+ *
+ * See https://reactnative.dev/docs/animated#event
+ */
+export declare const event: typeof AnimatedImplementation.event;
+export declare type event = typeof event;
+/**
+ * Advanced imperative API for snooping on animated events that are passed in
+ * through props. Use values directly where possible.
+ *
+ * See https://reactnative.dev/docs/animated#forkevent
+ */
+export declare const forkEvent: typeof AnimatedImplementation.forkEvent;
+export declare type forkEvent = typeof forkEvent;
+/**
+ * Loops a given animation continuously, so that each time it reaches the
+ * end, it resets and begins again from the start.
+ *
+ * See https://reactnative.dev/docs/animated#loop
+ */
+export declare const loop: typeof AnimatedImplementation.loop;
+export declare type loop = typeof loop;
+/**
+ * Creates a new Animated value that is the (non-negative) modulo of the
+ * provided Animated value.
+ *
+ * See https://reactnative.dev/docs/animated#modulo
+ */
+export declare const modulo: typeof AnimatedImplementation.modulo;
+export declare type modulo = typeof modulo;
+/**
+ * Creates a new Animated value composed from two Animated values multiplied
+ * together.
+ *
+ * See https://reactnative.dev/docs/animated#multiply
+ */
+export declare const multiply: typeof AnimatedImplementation.multiply;
+export declare type multiply = typeof multiply;
+/**
+ * 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.
+ *
+ * See https://reactnative.dev/docs/animated#parallel
+ */
+export declare const parallel: typeof AnimatedImplementation.parallel;
+export declare type parallel = typeof parallel;
+/**
+ * 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.
+ *
+ * See https://reactnative.dev/docs/animated#sequence
+ */
+export declare const sequence: typeof AnimatedImplementation.sequence;
+export declare type sequence = typeof sequence;
+/**
+ * Animates a value according to an analytical spring model based on
+ * damped harmonic oscillation.
+ *
+ * See https://reactnative.dev/docs/animated#spring
+ */
+export declare const spring: typeof AnimatedImplementation.spring;
+export declare type spring = typeof spring;
+/**
+ * Array of animations may run in parallel (overlap), but are started in
+ * sequence with successive delays. Nice for doing trailing effects.
+ *
+ * See https://reactnative.dev/docs/animated#stagger
+ */
+export declare const stagger: typeof AnimatedImplementation.stagger;
+export declare type stagger = typeof stagger;
+/**
+ * Creates a new Animated value composed by subtracting the second Animated
+ * value from the first Animated value.
+ *
+ * See https://reactnative.dev/docs/animated#subtract
+ */
+export declare const subtract: typeof AnimatedImplementation.subtract;
+export declare type subtract = typeof subtract;
+/**
+ * Animates a value along a timed easing curve. The Easing module has tons of
+ * predefined curves, or you can use your own function.
+ *
+ * See https://reactnative.dev/docs/animated#timing
+ */
+export declare const timing: typeof AnimatedImplementation.timing;
+export declare type timing = typeof timing;
+export declare const unforkEvent: typeof AnimatedImplementation.unforkEvent;
+export declare type unforkEvent = typeof unforkEvent;