react-native-reanimated 2.4.0 → 2.6.0

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 {};

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

@@ -0,0 +1,9 @@
+import { NextAnimation, DelayAnimation, RepeatAnimation, SequenceAnimation, StyleLayoutAnimation } from './commonTypes';
+import { AnimatedStyle, SharedValue, AnimatableValue, Animation, AnimationObject } from '../commonTypes';
+export declare type UserUpdater = () => AnimatedStyle;
+export declare function initialUpdaterRun<T>(updater: () => T): T;
+declare type AnimationToDecoration<T extends AnimationObject | StyleLayoutAnimation> = T extends StyleLayoutAnimation ? Record<string, unknown> : T extends DelayAnimation ? NextAnimation<DelayAnimation> : T extends RepeatAnimation ? NextAnimation<RepeatAnimation> : T extends SequenceAnimation ? NextAnimation<SequenceAnimation> : AnimatableValue | T;
+export declare function defineAnimation<T extends AnimationObject | StyleLayoutAnimation>(starting: AnimationToDecoration<T>, factory: () => T): T;
+export declare function cancelAnimation<T>(sharedValue: SharedValue<T>): void;
+export declare function withStartValue(startValue: AnimatableValue, animation: NextAnimation<AnimationObject>): Animation<AnimationObject>;
+export {};

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

@@ -0,0 +1,80 @@
+import { PerpectiveTransform, RotateTransform, RotateXTransform, RotateYTransform, RotateZTransform, ScaleTransform, ScaleXTransform, ScaleYTransform, TranslateXTransform, TranslateYTransform, SkewXTransform, SkewYTransform, MatrixTransform, ViewStyle, TextStyle } from 'react-native';
+import { Context } from './hook/commonTypes';
+export declare type TransformProperty = PerpectiveTransform | RotateTransform | RotateXTransform | RotateYTransform | RotateZTransform | ScaleTransform | ScaleXTransform | ScaleYTransform | TranslateXTransform | TranslateYTransform | SkewXTransform | SkewYTransform | MatrixTransform;
+export interface StyleProps extends ViewStyle, TextStyle {
+    originX?: number;
+    originY?: number;
+    [key: string]: any;
+}
+export interface AnimatedStyle extends Record<string, Animation<AnimationObject>> {
+    [key: string]: any;
+    transform?: Array<Record<string, Animation<AnimationObject>>>;
+}
+export interface SharedValue<T> {
+    value: T;
+}
+export interface WorkletFunction {
+    _closure?: Context;
+    __workletHash?: number;
+    __optimalization?: number;
+    __worklet?: boolean;
+}
+export interface BasicWorkletFunction<T> extends WorkletFunction {
+    (): T;
+}
+export interface BasicWorkletFunctionOptional<T> extends WorkletFunction {
+    (): Partial<T>;
+}
+export interface NativeEvent<T> {
+    nativeEvent: T;
+}
+export interface ComplexWorkletFunction<A extends any[], R> extends WorkletFunction {
+    (...args: A): R;
+}
+export interface NestedObject<T> {
+    [key: string]: NestedObjectValues<T>;
+}
+export declare type NestedObjectValues<T> = T | Array<NestedObjectValues<T>> | NestedObject<T>;
+export interface AdapterWorkletFunction extends WorkletFunction {
+    (value: NestedObject<string | number | AnimationObject>): void;
+}
+export declare type AnimatableValue = number | string | Array<number>;
+export interface AnimationObject {
+    [key: string]: any;
+    callback: AnimationCallback;
+    current?: AnimatableValue;
+    toValue?: AnimationObject['current'];
+    startValue?: AnimationObject['current'];
+    finished?: boolean;
+    strippedCurrent?: number;
+    cancelled?: boolean;
+    __prefix?: string;
+    __suffix?: string;
+    onFrame: (animation: any, timestamp: Timestamp) => boolean;
+    onStart: (nextAnimation: any, current: any, timestamp: Timestamp, previousAnimation: any) => void;
+}
+export interface Animation<T extends AnimationObject> extends AnimationObject {
+    onFrame: (animation: T, timestamp: Timestamp) => boolean;
+    onStart: (nextAnimation: T, current: T extends NumericAnimation ? number : AnimatableValue, timestamp: Timestamp, previousAnimation: T) => void;
+}
+export interface NumericAnimation {
+    current?: number;
+}
+export declare type AnimationCallback = (finished?: boolean, current?: AnimatableValue) => void;
+export declare type Timestamp = number;
+export declare type Value3D = {
+    x: number;
+    y: number;
+    z: number;
+};
+export declare type SensorValue3D = SharedValue<Value3D>;
+export declare type ValueRotation = {
+    qw: number;
+    qx: number;
+    qy: number;
+    qz: number;
+    yaw: number;
+    pitch: number;
+    roll: number;
+};
+export declare type SensorValueRotation = SharedValue<ValueRotation>;

package/lib/types/lib/reanimated2/component/FlatList.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { FlatListProps } from 'react-native';
+import { ILayoutAnimationBuilder } from '../layoutReanimation/animationBuilder/commonTypes';
+export interface ReanimatedFlatlistProps<ItemT> extends FlatListProps<ItemT> {
+    itemLayoutAnimation?: ILayoutAnimationBuilder;
+}
+declare type ReanimatedFlatListFC<T = any> = React.FC<ReanimatedFlatlistProps<T>>;
+declare const ReanimatedFlatlist: ReanimatedFlatListFC;
+export default ReanimatedFlatlist;

package/lib/types/lib/reanimated2/component/WrappedComponents.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+declare const WrappedComponents: {
+    View: import("react").ComponentType<import("../../createAnimatedComponent").AnimatedComponentProps<import("../../createAnimatedComponent").InitialComponentProps>>;
+    Text: import("react").ComponentType<import("../../createAnimatedComponent").AnimatedComponentProps<import("../../createAnimatedComponent").InitialComponentProps>>;
+    Image: import("react").ComponentType<import("../../createAnimatedComponent").AnimatedComponentProps<import("../../createAnimatedComponent").InitialComponentProps>>;
+    ScrollView: import("react").ComponentType<import("../../createAnimatedComponent").AnimatedComponentProps<import("../../createAnimatedComponent").InitialComponentProps>>;
+};
+export default WrappedComponents;

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

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+declare const ReanimatedComponents: {
+    FlatList: import("react").FC<import("./FlatList").ReanimatedFlatlistProps<any>>;
+    View: import("react").ComponentType<import("../../createAnimatedComponent").AnimatedComponentProps<import("../../createAnimatedComponent").InitialComponentProps>>;
+    Text: import("react").ComponentType<import("../../createAnimatedComponent").AnimatedComponentProps<import("../../createAnimatedComponent").InitialComponentProps>>;
+    Image: import("react").ComponentType<import("../../createAnimatedComponent").AnimatedComponentProps<import("../../createAnimatedComponent").InitialComponentProps>>;
+    ScrollView: import("react").ComponentType<import("../../createAnimatedComponent").AnimatedComponentProps<import("../../createAnimatedComponent").InitialComponentProps>>;
+};
+export default ReanimatedComponents;