react-native-reanimated 2.4.1 → 2.7.0

package/lib/reanimated2/layoutReanimation/defaultTransitions/EntryExitTransition.js

@@ -74,24 +74,28 @@ export class EntryExitTransition extends BaseAnimationBuilder {
                     }
                 }
                 const mergedTransform = ((_c = exitingValues.initialValues.transform) !== null && _c !== void 0 ? _c : []).concat(((_d = enteringValues.animations.transform) !== null && _d !== void 0 ? _d : []).map((value) => {
-                    for (const transformProp of Object.keys(value)) {
-                        const current = value[transformProp].current;
-                        if (typeof current === 'string') {
-                            if (current.includes('deg'))
-                                return {
-                                    [transformProp]: '0deg',
-                                };
-                            else
-                                return {
-                                    [transformProp]: '0',
-                                };
-                        }
-                        else if (transformProp.includes('translate')) {
-                            return { [transformProp]: 0 };
-                        }
-                        else {
-                            return { [transformProp]: 1 };
-                        }
+                    const objectKeys = Object.keys(value);
+                    if ((objectKeys === null || objectKeys === void 0 ? void 0 : objectKeys.length) < 1) {
+                        console.error(`[Reanimated]: \${value} is not a valid Transform object`);
+                        return value;
+                    }
+                    const transformProp = objectKeys[0];
+                    const current = value[transformProp].current;
+                    if (typeof current === 'string') {
+                        if (current.includes('deg'))
+                            return {
+                                [transformProp]: '0deg',
+                            };
+                        else
+                            return {
+                                [transformProp]: '0',
+                            };
+                    }
+                    else if (transformProp.includes('translate')) {
+                        return { [transformProp]: 0 };
+                    }
+                    else {
+                        return { [transformProp]: 1 };
                     }
                     return value;
                 }));

package/lib/reanimated2/mock.js

@@ -1,5 +1,5 @@
 "use strict";
-/* eslint-disable standard/no-callback-literal */
+/* eslint-disable node/no-callback-literal */
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-nocheck
 const NOOP = () => {
@@ -58,7 +58,8 @@ const ReanimatedV2 = {
         elastic: ID,
         back: ID,
         bounce: ID,
-        bezier: ID,
+        bezier: () => ({ factory: ID }),
+        bezierFn: ID,
         in: ID,
         out: ID,
         inOut: ID,

package/lib/types/lib/ConfigHelper.d.ts

@@ -0,0 +1,12 @@
+export declare function addWhitelistedNativeProps(props: Record<string, boolean>): void;
+export declare function addWhitelistedUIProps(props: Record<string, boolean>): void;
+interface ViewConfig {
+    uiViewClassName: string;
+    validAttributes: Record<string, unknown>;
+}
+/**
+ * updates UI props whitelist for given view host instance
+ * this will work just once for every view name
+ */
+export declare function adaptViewConfig(viewConfig: ViewConfig): void;
+export {};

package/lib/types/lib/ReanimatedEventEmitter.d.ts

@@ -0,0 +1,3 @@
+import { NativeEventEmitter } from 'react-native';
+declare const _default: NativeEventEmitter;
+export default _default;

package/lib/types/lib/ReanimatedModule.d.ts

@@ -0,0 +1,2 @@
+import ReanimatedModuleCompat from './ReanimatedModuleCompat';
+export default ReanimatedModuleCompat;

package/lib/types/lib/ReanimatedModule.macos.d.ts

@@ -0,0 +1,2 @@
+import ReanimatedModuleCompat from './ReanimatedModuleCompat';
+export default ReanimatedModuleCompat;

package/lib/types/lib/ReanimatedModule.native.d.ts

@@ -0,0 +1,2 @@
+declare let exportedModule: any;
+export default exportedModule;

package/lib/types/lib/ReanimatedModule.windows.d.ts

@@ -0,0 +1,2 @@
+import ReanimatedModuleCompat from './ReanimatedModuleCompat';
+export default ReanimatedModuleCompat;

package/lib/types/lib/ReanimatedModuleCompat.d.ts

@@ -0,0 +1,14 @@
+declare const _default: {
+    disconnectNodeFromView(): Promise<void>;
+    attachEvent(_viewTag: number, _eventName: string, _nodeID: number): Promise<void>;
+    detachEvent(_viewTag: number, _eventName: string, _nodeID: number): Promise<void>;
+    createNode(_nodeID: number, _config: Record<string, unknown>): Promise<void>;
+    dropNode(_nodeID: number): Promise<void>;
+    configureProps(_nativeProps: string[], _uiProps: string[]): Promise<void>;
+    disconnectNodes(): Promise<void>;
+    addListener(): Promise<void>;
+    removeListeners(): Promise<void>;
+    removeAllListeners(): Promise<void>;
+    animateNextTransition(): Promise<void>;
+};
+export default _default;

package/lib/types/lib/createAnimatedComponent.d.ts

@@ -0,0 +1,33 @@
+import { Component, ComponentType, Ref } from 'react';
+import './reanimated2/layoutReanimation/LayoutAnimationRepository';
+import { BaseAnimationBuilder, EntryExitAnimationFunction, ILayoutAnimationBuilder } from './reanimated2/layoutReanimation';
+import { SharedValue, StyleProps } from './reanimated2/commonTypes';
+import { ViewDescriptorsSet, ViewRefSet } from './reanimated2/ViewDescriptorsSet';
+declare type NestedArray<T> = T | NestedArray<T>[];
+interface AnimatedProps extends Record<string, unknown> {
+    viewDescriptors?: ViewDescriptorsSet;
+    viewsRef?: ViewRefSet<unknown>;
+    initial?: SharedValue<StyleProps>;
+}
+export declare type AnimatedComponentProps<P extends Record<string, unknown>> = P & {
+    forwardedRef?: Ref<Component>;
+    style?: NestedArray<StyleProps>;
+    animatedProps?: Partial<AnimatedComponentProps<AnimatedProps>>;
+    animatedStyle?: StyleProps;
+    layout?: BaseAnimationBuilder | ILayoutAnimationBuilder | typeof BaseAnimationBuilder;
+    entering?: BaseAnimationBuilder | typeof BaseAnimationBuilder | EntryExitAnimationFunction | Keyframe;
+    exiting?: BaseAnimationBuilder | typeof BaseAnimationBuilder | EntryExitAnimationFunction | Keyframe;
+};
+declare type Options<P> = {
+    setNativeProps: (ref: ComponentRef, props: P) => void;
+};
+interface ComponentRef extends Component {
+    setNativeProps?: (props: Record<string, unknown>) => void;
+    getScrollableNode?: () => ComponentRef;
+}
+export interface InitialComponentProps extends Record<string, unknown> {
+    ref?: Ref<Component>;
+    collapsable?: boolean;
+}
+export default function createAnimatedComponent(Component: ComponentType<InitialComponentProps>, options?: Options<InitialComponentProps>): ComponentType<AnimatedComponentProps<InitialComponentProps>>;
+export {};

package/lib/types/lib/reanimated2/Bezier.d.ts

@@ -0,0 +1,6 @@
+/**
+ * https://github.com/gre/bezier-easing
+ * BezierEasing - use bezier curve for transition easing function
+ * by Gaëtan Renaudeau 2014 - 2015 – MIT License
+ */
+export declare function Bezier(mX1: number, mY1: number, mX2: number, mY2: number): (x: number) => number;

package/lib/types/lib/reanimated2/Colors.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Copied from:
+ * react-native/Libraries/StyleSheet/normalizeColor.js
+ * react-native/Libraries/StyleSheet/processColor.js
+ * https://github.com/wcandillon/react-native-redash/blob/master/src/Colors.ts
+ */
+interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
+interface HSV {
+    h: number;
+    s: number;
+    v: number;
+}
+export declare const opacity: (c: number) => number;
+export declare const red: (c: number) => number;
+export declare const green: (c: number) => number;
+export declare const blue: (c: number) => number;
+export declare const rgbaColor: (r: number, g: number, b: number, alpha?: number) => number | string;
+export declare function RGBtoHSV(rgb: RGB): HSV;
+export declare function RGBtoHSV(r: number, g: number, b: number): HSV;
+export declare const hsvToColor: (h: number, s: number, v: number) => number | string;
+export declare function processColorInitially(color: unknown): number | null | undefined;
+export declare function isColor(value: unknown): boolean;
+export declare function processColor(color: unknown): number | null | undefined;
+export declare type ParsedColorArray = [number, number, number, number];
+export declare function convertToHSVA(color: unknown): ParsedColorArray;
+export declare function toRGBA(HSVA: ParsedColorArray): string;
+export {};

package/lib/types/lib/reanimated2/Easing.d.ts

@@ -0,0 +1,172 @@
+/**
+ * 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
+ */
+export declare type EasingFn = (t: number) => number;
+export declare type EasingFactoryFn = {
+    factory: () => EasingFn;
+};
+/**
+ * A linear function, `f(t) = t`. Position correlates to elapsed time one to
+ * one.
+ *
+ * http://cubic-bezier.com/#0,0,1,1
+ */
+declare function linear(t: number): number;
+/**
+ * A simple inertial interaction, similar to an object slowly accelerating to
+ * speed.
+ *
+ * http://cubic-bezier.com/#.42,0,1,1
+ */
+declare function ease(t: number): number;
+/**
+ * A quadratic function, `f(t) = t * t`. Position equals the square of elapsed
+ * time.
+ *
+ * http://easings.net/#easeInQuad
+ */
+declare function quad(t: number): number;
+/**
+ * A cubic function, `f(t) = t * t * t`. Position equals the cube of elapsed
+ * time.
+ *
+ * http://easings.net/#easeInCubic
+ */
+declare function 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
+ */
+declare function poly(n: number): EasingFn;
+/**
+ * A sinusoidal function.
+ *
+ * http://easings.net/#easeInSine
+ */
+declare function sin(t: number): number;
+/**
+ * A circular function.
+ *
+ * http://easings.net/#easeInCirc
+ */
+declare function circle(t: number): number;
+/**
+ * An exponential function.
+ *
+ * http://easings.net/#easeInExpo
+ */
+declare function 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
+ */
+declare function elastic(bounciness?: number): EasingFn;
+/**
+ * Use with `Animated.parallel()` to create a simple effect where the object
+ * animates back slightly as the animation starts.
+ *
+ * Wolfram Plot:
+ *
+ * - http://tiny.cc/back_default (s = 1.70158, default)
+ */
+declare function back(s?: number): (t: number) => number;
+/**
+ * Provides a simple bouncing effect.
+ *
+ * http://easings.net/#easeInBounce
+ */
+declare function 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/
+ */
+declare function bezier(x1: number, y1: number, x2: number, y2: number): {
+    factory: () => (x: number) => number;
+};
+declare function bezierFn(x1: number, y1: number, x2: number, y2: number): (x: number) => number;
+/**
+ * Runs an easing function forwards.
+ */
+declare function in_(easing: EasingFn): EasingFn;
+/**
+ * Runs an easing function backwards.
+ */
+declare function out(easing: EasingFn): EasingFn;
+/**
+ * Makes any easing function symmetrical. The easing function will run
+ * forwards for half of the duration, then backwards for the rest of the
+ * duration.
+ */
+declare function inOut(easing: EasingFn): EasingFn;
+export declare const Easing: {
+    linear: typeof linear;
+    ease: typeof ease;
+    quad: typeof quad;
+    cubic: typeof cubic;
+    poly: typeof poly;
+    sin: typeof sin;
+    circle: typeof circle;
+    exp: typeof exp;
+    elastic: typeof elastic;
+    back: typeof back;
+    bounce: typeof bounce;
+    bezier: typeof bezier;
+    bezierFn: typeof bezierFn;
+    in: typeof in_;
+    out: typeof out;
+    inOut: typeof inOut;
+};
+export {};

package/lib/types/lib/reanimated2/NativeMethods.d.ts

@@ -0,0 +1,14 @@
+import { Component } from 'react';
+import { RefObjectFunction } from './commonTypes';
+export declare function getTag(view: null | number | React.Component<any, any> | React.ComponentClass<any>): null | number;
+export interface MeasuredDimensions {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    pageX: number;
+    pageY: number;
+}
+export declare function measure(animatedRef: RefObjectFunction<Component>): MeasuredDimensions;
+export declare function scrollTo(animatedRef: RefObjectFunction<Component>, x: number, y: number, animated: boolean): void;
+export declare function setGestureState(handlerTag: number, newState: number): void;

package/lib/types/lib/reanimated2/NativeReanimated/NativeReanimated.d.ts

@@ -0,0 +1,20 @@
+import { SharedValue, SensorValue3D, SensorValueRotation } from '../commonTypes';
+import { Descriptor } from '../hook/commonTypes';
+export declare class NativeReanimated {
+    native: boolean;
+    private InnerNativeModule;
+    constructor(native?: boolean);
+    installCoreFunctions(valueSetter: <T>(value: T) => void): void;
+    makeShareable<T>(value: T): T;
+    makeMutable<T>(value: T): SharedValue<T>;
+    makeRemote<T>(object?: {}): T;
+    registerSensor(sensorType: number, interval: number, sensorData: SensorValue3D | SensorValueRotation): any;
+    unregisterSensor(sensorId: number): any;
+    startMapper(mapper: () => void, inputs: any[] | undefined, outputs: any[] | undefined, updater: () => void, viewDescriptors: Descriptor[] | SharedValue<Descriptor[]>): number;
+    stopMapper(mapperId: number): void;
+    registerEventHandler<T>(eventHash: string, eventHandler: (event: T) => void): string;
+    unregisterEventHandler(id: string): void;
+    getViewProp<T>(viewTag: string, propName: string, callback?: (result: T) => void): Promise<T>;
+    enableLayoutAnimations(flag: boolean): void;
+    configureProps(uiProps: string[], nativeProps: string[]): void;
+}

package/lib/types/lib/reanimated2/NativeReanimated/index.d.ts

@@ -0,0 +1,3 @@
+import { NativeReanimated } from './NativeReanimated';
+declare const _default: NativeReanimated;
+export default _default;

package/lib/types/lib/reanimated2/PlatformChecker.d.ts

@@ -0,0 +1,5 @@
+export declare function isJest(): boolean;
+export declare function isChromeDebugger(): boolean;
+export declare function isWeb(): boolean;
+export declare function shouldBeUseWeb(): boolean;
+export declare function nativeShouldBeMock(): boolean;

package/lib/types/lib/reanimated2/PropAdapters.d.ts

@@ -0,0 +1,4 @@
+import { AdapterWorkletFunction } from './commonTypes';
+export declare function createAnimatedPropAdapter(adapter: AdapterWorkletFunction, nativeProps?: string[]): AdapterWorkletFunction;
+export declare const SVGAdapter: AdapterWorkletFunction;
+export declare const TextInputAdapter: AdapterWorkletFunction;

package/lib/types/lib/reanimated2/UpdateProps.d.ts

@@ -0,0 +1,9 @@
+import { MutableRefObject } from 'react';
+import { AnimatedStyle, SharedValue, StyleProps } from './commonTypes';
+import { Descriptor } from './hook/commonTypes';
+import { ViewRefSet } from './ViewDescriptorsSet';
+export declare const colorProps: string[];
+export declare const ColorProperties: string[];
+export declare const updateProps: (viewDescriptor: SharedValue<Descriptor[]>, updates: StyleProps | AnimatedStyle, maybeViewRef: ViewRefSet<any> | undefined) => void;
+export declare const updatePropsJestWrapper: (viewDescriptors: SharedValue<Descriptor[]>, updates: AnimatedStyle, maybeViewRef: ViewRefSet<any> | undefined, animatedStyle: MutableRefObject<AnimatedStyle>, adapters: ((updates: AnimatedStyle) => void)[]) => void;
+export default updateProps;

package/lib/types/lib/reanimated2/ViewDescriptorsSet.d.ts

@@ -0,0 +1,20 @@
+import { SharedValue } from './commonTypes';
+import { Descriptor } from './hook/commonTypes';
+export interface ViewRefSet<T> {
+    items: Set<T>;
+    add: (item: T) => void;
+    remove: (item: T) => void;
+}
+export interface ViewDescriptorsSet {
+    batchToRemove: Set<number>;
+    tags: Set<number>;
+    waitForInsertSync: boolean;
+    waitForRemoveSync: boolean;
+    sharableViewDescriptors: SharedValue<Descriptor[]>;
+    items: Descriptor[];
+    add: (item: Descriptor) => void;
+    remove: (viewTag: number) => void;
+    rebuildsharableViewDescriptors: (sharableViewDescriptor: SharedValue<Descriptor[]>) => void;
+}
+export declare function makeViewDescriptorsSet(): ViewDescriptorsSet;
+export declare function makeViewsRefSet<T>(): ViewRefSet<T>;

package/lib/types/lib/reanimated2/WorkletEventHandler.d.ts

@@ -0,0 +1,13 @@
+import { NativeEvent } from './commonTypes';
+export default class WorkletEventHandler<T extends NativeEvent<T>> {
+    worklet: (event: T) => void;
+    eventNames: string[];
+    reattachNeeded: boolean;
+    listeners: Record<string, (event: T) => void>;
+    viewTag: number | undefined;
+    registrations: string[];
+    constructor(worklet: (event: T) => void, eventNames?: string[]);
+    updateWorklet(newWorklet: (event: T) => void): void;
+    registerForEvents(viewTag: number, fallbackEventName?: string): void;
+    unregisterFromEvents(): void;
+}

package/lib/types/lib/reanimated2/__mocks__/MutableValue.d.ts

@@ -0,0 +1,5 @@
+export default class MutableValue {
+    constructor(value: any);
+    get value(): any;
+    set value(nextValue: any);
+}

package/lib/types/lib/reanimated2/__mocks__/NativeReanimated.d.ts

@@ -0,0 +1,13 @@
+import MutableValue from './MutableValue';
+declare const _default: {
+    installCoreFunctions: () => void;
+    makeShareable: (worklet: any) => any;
+    makeMutable: (init: any) => MutableValue;
+    makeRemote: () => void;
+    startMapper: () => void;
+    stopMapper: () => void;
+    registerEventHandler: () => void;
+    unregisterEventHandler: () => void;
+    getViewProp: () => void;
+};
+export default _default;

package/lib/types/lib/reanimated2/__mocks__/NativeReanimated.native.d.ts

@@ -0,0 +1,13 @@
+import MutableValue from './MutableValue';
+declare const _default: {
+    installCoreFunctions: () => void;
+    makeShareable: (worklet: any) => any;
+    makeMutable: (init: any) => MutableValue;
+    makeRemote: () => void;
+    startMapper: () => void;
+    stopMapper: () => void;
+    registerEventHandler: () => void;
+    unregisterEventHandler: () => void;
+    getViewProp: () => void;
+};
+export default _default;

package/lib/types/lib/reanimated2/animation/commonTypes.d.ts

@@ -0,0 +1,27 @@
+import { AnimatedStyle, StyleProps, AnimatableValue, AnimationObject, Animation, Timestamp, AnimationCallback } from '../commonTypes';
+export interface HigherOrderAnimation {
+    isHigherOrder?: boolean;
+}
+export declare type NextAnimation<T extends AnimationObject> = T | (() => T);
+export interface DelayAnimation extends Animation<DelayAnimation>, HigherOrderAnimation {
+    startTime: Timestamp;
+    started: boolean;
+    previousAnimation: DelayAnimation | null;
+    current: AnimatableValue;
+}
+export interface RepeatAnimation extends Animation<RepeatAnimation>, HigherOrderAnimation {
+    reps: number;
+    startValue: AnimatableValue;
+    toValue?: AnimatableValue;
+    previousAnimation?: RepeatAnimation;
+}
+export interface SequenceAnimation extends Animation<SequenceAnimation>, HigherOrderAnimation {
+    animationIndex: number;
+}
+export interface StyleLayoutAnimation extends HigherOrderAnimation {
+    current: StyleProps;
+    styleAnimations: AnimatedStyle;
+    onFrame: (animation: StyleLayoutAnimation, timestamp: Timestamp) => boolean;
+    onStart: (nextAnimation: StyleLayoutAnimation, current: AnimatedStyle, timestamp: Timestamp, previousAnimation: StyleLayoutAnimation) => void;
+    callback?: AnimationCallback;
+}

package/lib/types/lib/reanimated2/animation/decay.d.ts

@@ -0,0 +1,19 @@
+import { Animation, AnimationCallback, AnimationObject, AnimatableValue, Timestamp } from '../commonTypes';
+interface DecayConfig {
+    deceleration?: number;
+    velocityFactor?: number;
+    clamp?: number[];
+    velocity?: number;
+}
+export interface DecayAnimation extends Animation<DecayAnimation> {
+    lastTimestamp: Timestamp;
+    startTimestamp: Timestamp;
+    initialVelocity: number;
+    velocity: number;
+    current: AnimatableValue;
+}
+export interface InnerDecayAnimation extends Omit<DecayAnimation, 'current'>, AnimationObject {
+    current: number;
+}
+export declare function withDecay(userConfig: DecayConfig, callback?: AnimationCallback): Animation<DecayAnimation>;
+export {};

package/lib/types/lib/reanimated2/animation/delay.d.ts

@@ -0,0 +1,7 @@
+import { Animation } from '../commonTypes';
+import { NextAnimation, DelayAnimation } from './commonTypes';
+export declare function withDelay(delayMs: number, _nextAnimation: NextAnimation<DelayAnimation>): Animation<DelayAnimation>;
+/**
+ * @deprecated Kept for backward compatibility. Will be removed soon.
+ */
+export declare function delay(delayMs: number, _nextAnimation: NextAnimation<DelayAnimation>): Animation<DelayAnimation>;

package/lib/types/lib/reanimated2/animation/index.d.ts

@@ -0,0 +1,9 @@
+export { HigherOrderAnimation, NextAnimation, DelayAnimation, RepeatAnimation, SequenceAnimation, StyleLayoutAnimation, } from './commonTypes';
+export { cancelAnimation, defineAnimation, initialUpdaterRun } from './util';
+export { withTiming, TimingAnimation } from './timing';
+export { withSpring, SpringAnimation } from './spring';
+export { withDecay, DecayAnimation } from './decay';
+export { withDelay } from './delay';
+export { withRepeat } from './repeat';
+export { withSequence } from './sequence';
+export { withStyleAnimation } from './styleAnimation';

package/lib/types/lib/reanimated2/animation/repeat.d.ts

@@ -0,0 +1,12 @@
+import { Animation, AnimationCallback } from '../commonTypes';
+import { NextAnimation, RepeatAnimation } from './commonTypes';
+export interface InnerRepeatAnimation extends Omit<RepeatAnimation, 'toValue' | 'startValue'> {
+    toValue: number;
+    startValue: number;
+}
+export declare function withRepeat(_nextAnimation: NextAnimation<RepeatAnimation>, numberOfReps?: number, reverse?: boolean, callback?: AnimationCallback): Animation<RepeatAnimation>;
+/**
+ * @deprecated Kept for backward compatibility. Will be removed soon.
+ */
+export declare function repeat(_nextAnimation: NextAnimation<RepeatAnimation>, numberOfReps?: number, reverse?: boolean, callback?: AnimationCallback): Animation<RepeatAnimation>;
+export declare function loop(nextAnimation: NextAnimation<RepeatAnimation>, numberOfLoops?: number): Animation<RepeatAnimation>;

package/lib/types/lib/reanimated2/animation/sequence.d.ts

@@ -0,0 +1,7 @@
+import { NextAnimation, SequenceAnimation } from './commonTypes';
+import { Animation, AnimationObject } from '../commonTypes';
+export declare function withSequence(..._animations: NextAnimation<AnimationObject>[]): Animation<SequenceAnimation>;
+/**
+ * @deprecated Kept for backward compatibility. Will be removed soon.
+ */
+export declare function sequence(..._animations: NextAnimation<SequenceAnimation>[]): Animation<SequenceAnimation>;

package/lib/types/lib/reanimated2/animation/spring.d.ts

@@ -0,0 +1,22 @@
+import { Animation, AnimationCallback, AnimatableValue, Timestamp } from '../commonTypes';
+interface SpringConfig {
+    mass?: number;
+    stiffness?: number;
+    overshootClamping?: boolean;
+    restDisplacementThreshold?: number;
+    restSpeedThreshold?: number;
+    velocity?: number;
+    damping?: number;
+}
+export interface SpringAnimation extends Animation<SpringAnimation> {
+    current: AnimatableValue;
+    toValue: AnimatableValue;
+    velocity: number;
+    lastTimestamp: Timestamp;
+}
+export interface InnerSpringAnimation extends Omit<SpringAnimation, 'toValue' | 'current'> {
+    toValue: number;
+    current: number;
+}
+export declare function withSpring(toValue: AnimatableValue, userConfig?: SpringConfig, callback?: AnimationCallback): Animation<SpringAnimation>;
+export {};

package/lib/types/lib/reanimated2/animation/styleAnimation.d.ts

@@ -0,0 +1,7 @@
+import { AnimatableValue, AnimatedStyle, NestedObject, NestedObjectValues } from '../commonTypes';
+import { StyleLayoutAnimation } from './commonTypes';
+export declare function resolvePath<T>(obj: NestedObject<T>, path: AnimatableValue[] | AnimatableValue): NestedObjectValues<T> | undefined;
+declare type Path = Array<string | number> | string | number;
+export declare function setPath<T>(obj: NestedObject<T>, path: Path, value: NestedObjectValues<T>): void;
+export declare function withStyleAnimation(styleAnimations: AnimatedStyle): StyleLayoutAnimation;
+export {};

package/lib/types/lib/reanimated2/animation/timing.d.ts

@@ -0,0 +1,21 @@
+import { EasingFn, EasingFactoryFn } from '../Easing';
+import { Animation, AnimationCallback, Timestamp, AnimatableValue } from '../commonTypes';
+interface TimingConfig {
+    duration?: number;
+    easing?: EasingFn | EasingFactoryFn;
+}
+export interface TimingAnimation extends Animation<TimingAnimation> {
+    type: string;
+    easing: EasingFn;
+    startValue: AnimatableValue;
+    startTime: Timestamp;
+    progress: number;
+    toValue: AnimatableValue;
+    current: AnimatableValue;
+}
+export interface InnerTimingAnimation extends Omit<TimingAnimation, 'toValue' | 'current'> {
+    toValue: number;
+    current: number;
+}
+export declare function withTiming(toValue: AnimatableValue, userConfig?: TimingConfig, callback?: AnimationCallback): Animation<TimingAnimation>;
+export {};