react-native-reanimated 2.5.0 → 2.6.0

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;

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

@@ -0,0 +1,24 @@
+import { ComplexWorkletFunction, SharedValue, AnimationObject, AnimatableValue, Timestamp } from './commonTypes';
+import { Descriptor } from './hook/commonTypes';
+export declare type ReanimatedConsole = Pick<Console, 'debug' | 'log' | 'warn' | 'info' | 'error'>;
+export declare type WorkletValue = (() => AnimationObject) | AnimationObject | AnimatableValue | Descriptor;
+export declare const checkPluginState: (throwError: boolean) => boolean;
+export declare const isConfigured: (throwError?: boolean) => boolean;
+export declare const isConfiguredCheck: () => void;
+export declare function requestFrame(frame: (timestamp: Timestamp) => void): void;
+export declare function runOnUI<A extends any[], R>(worklet: ComplexWorkletFunction<A, R>): (...args: A) => void;
+export declare function makeShareable<T>(value: T): T;
+export declare function getViewProp<T>(viewTag: string, propName: string): Promise<T>;
+export declare function getTimestamp(): number;
+export declare function makeMutable<T>(value: T): SharedValue<T>;
+export declare function makeRemote<T>(object?: {}): T;
+export declare function startMapper(mapper: () => void, inputs?: any[], outputs?: any[], updater?: () => void, viewDescriptors?: Descriptor[] | SharedValue<Descriptor[]>): number;
+export declare function stopMapper(mapperId: number): void;
+export interface RunOnJSFunction<A extends any[], R> {
+    __callAsync?: (...args: A) => void;
+    (...args: A): R;
+}
+export declare function runOnJS<A extends any[], R>(fun: RunOnJSFunction<A, R>): () => void;
+export declare function enableLayoutAnimations(flag: boolean, isCallByUser?: boolean): void;
+export declare function configureProps(uiProps: string[], nativeProps: string[]): void;
+export declare function jestResetJsReanimatedModule(): void;

package/lib/types/lib/reanimated2/hook/Hooks.d.ts

@@ -0,0 +1,5 @@
+import { DependencyList } from './commonTypes';
+import { useAnimatedStyle } from './useAnimatedStyle';
+export declare const useAnimatedProps: typeof useAnimatedStyle;
+export declare function useWorkletCallback<A extends unknown[], R>(fun: (...args: A) => R, deps?: DependencyList): (...args: Parameters<typeof fun>) => R;
+export { useEvent, useHandler } from './utils';

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

@@ -0,0 +1,14 @@
+export declare type DependencyList = Array<unknown> | undefined;
+export declare type Context = Record<string, unknown>;
+export interface ContextWithDependencies<TContext extends Context> {
+    context: TContext;
+    savedDependencies: DependencyList;
+}
+export interface Descriptor {
+    tag: number;
+    name: string;
+}
+export interface RefObjectFunction<T> {
+    current: T | null;
+    (component?: T): number;
+}

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

@@ -0,0 +1,10 @@
+export { DependencyList, Context } from './commonTypes';
+export { useAnimatedProps, useEvent, useHandler, useWorkletCallback, } from './Hooks';
+export { useSharedValue } from './useSharedValue';
+export { useAnimatedStyle, AnimatedStyleResult } from './useAnimatedStyle';
+export { useAnimatedGestureHandler, GestureHandlerEvent, GestureHandlers, } from './useAnimatedGestureHandler';
+export { useAnimatedReaction, AnimatedReactionWorkletFunction, } from './useAnimatedReaction';
+export { useAnimatedRef } from './useAnimatedRef';
+export { useAnimatedScrollHandler, ScrollHandler, ScrollHandlers, } from './useAnimatedScrollHandler';
+export { useDerivedValue, DerivedValue } from './useDerivedValue';
+export { useAnimatedSensor, SensorType } from './useAnimatedSensor';

package/lib/types/lib/reanimated2/hook/useAnimatedGestureHandler.d.ts

@@ -0,0 +1,35 @@
+import { MutableRefObject } from 'react';
+import { WorkletFunction } from '../commonTypes';
+import WorkletEventHandler from '../WorkletEventHandler';
+import { Context, DependencyList } from './commonTypes';
+interface Handler<T, TContext extends Context> extends WorkletFunction {
+    (event: T, context: TContext, isCanceledOrFailed?: boolean): void;
+}
+export interface GestureHandlers<T, TContext extends Context> {
+    [key: string]: Handler<T, TContext> | undefined;
+    onStart?: Handler<T, TContext>;
+    onActive?: Handler<T, TContext>;
+    onEnd?: Handler<T, TContext>;
+    onFail?: Handler<T, TContext>;
+    onCancel?: Handler<T, TContext>;
+    onFinish?: Handler<T, TContext>;
+}
+export declare enum EventType {
+    UNDETERMINED = 0,
+    FAILED = 1,
+    BEGAN = 2,
+    CANCELLED = 3,
+    ACTIVE = 4,
+    END = 5
+}
+export interface GestureHandlerStateChangeNativeEvent {
+    handlerTag: number;
+    numberOfPointers: number;
+    state: EventType;
+    oldState: EventType;
+}
+export interface GestureHandlerEvent<T> extends GestureHandlerStateChangeNativeEvent {
+    nativeEvent: T;
+}
+export declare function useAnimatedGestureHandler<T extends GestureHandlerEvent<T>, TContext extends Context>(handlers: GestureHandlers<T, TContext>, dependencies?: DependencyList): MutableRefObject<WorkletEventHandler<T> | null> | ((e: T) => void);
+export {};

package/lib/types/lib/reanimated2/hook/useAnimatedReaction.d.ts

@@ -0,0 +1,12 @@
+import { BasicWorkletFunction, WorkletFunction } from '../commonTypes';
+import { DependencyList } from './commonTypes';
+export interface AnimatedReactionWorkletFunction<T> extends WorkletFunction {
+    (prepared: T, previous: T | null): void;
+}
+/**
+ * @param prepare - worklet used for data preparation for the second parameter
+ * @param react - worklet which takes data prepared by the one in the first parameter and performs certain actions
+ * the first worklet defines the inputs, in other words on which shared values change will it be called.
+ * the second one can modify any shared values but those which are mentioned in the first worklet. Beware of that, because this may result in endless loop and high cpu usage.
+ */
+export declare function useAnimatedReaction<T>(prepare: BasicWorkletFunction<T>, react: AnimatedReactionWorkletFunction<T>, dependencies: DependencyList): void;

package/lib/types/lib/reanimated2/hook/useAnimatedRef.d.ts

@@ -0,0 +1,3 @@
+import { Component } from 'react';
+import { RefObjectFunction } from './commonTypes';
+export declare function useAnimatedRef<T extends Component>(): RefObjectFunction<T>;

package/lib/types/lib/reanimated2/hook/useAnimatedScrollHandler.d.ts

@@ -0,0 +1,21 @@
+import { RefObject } from 'react';
+import { NativeScrollEvent } from 'react-native';
+import { NativeEvent, WorkletFunction } from '../commonTypes';
+import WorkletEventHandler from '../WorkletEventHandler';
+import { Context, DependencyList } from './commonTypes';
+export interface ScrollHandler<TContext extends Context> extends WorkletFunction {
+    (event: NativeScrollEvent, context?: TContext): void;
+}
+interface ScrollEvent extends NativeScrollEvent, NativeEvent<ScrollEvent> {
+    eventName: string;
+}
+export interface ScrollHandlers<TContext extends Context> {
+    [key: string]: ScrollHandler<TContext> | undefined;
+    onScroll?: ScrollHandler<TContext>;
+    onBeginDrag?: ScrollHandler<TContext>;
+    onEndDrag?: ScrollHandler<TContext>;
+    onMomentumBegin?: ScrollHandler<TContext>;
+    onMomentumEnd?: ScrollHandler<TContext>;
+}
+export declare function useAnimatedScrollHandler<TContext extends Context>(handlers: ScrollHandlers<TContext> | ScrollHandler<TContext>, dependencies?: DependencyList): RefObject<WorkletEventHandler<ScrollEvent>>;
+export {};

package/lib/types/lib/reanimated2/hook/useAnimatedSensor.d.ts

@@ -0,0 +1,20 @@
+import { SensorValue3D, SensorValueRotation } from '../commonTypes';
+export declare enum SensorType {
+    ACCELEROMETER = 1,
+    GYROSCOPE = 2,
+    GRAVITY = 3,
+    MAGNETIC_FIELD = 4,
+    ROTATION = 5
+}
+export declare type SensorConfig = {
+    interval: number;
+};
+export declare type AnimatedSensor = {
+    sensor: SensorValue3D | SensorValueRotation | null;
+    unregister: () => void;
+    isAvailable: boolean;
+    config: {
+        interval: number;
+    };
+};
+export declare function useAnimatedSensor(sensorType: SensorType, userConfig?: SensorConfig): AnimatedSensor;

package/lib/types/lib/reanimated2/hook/useAnimatedStyle.d.ts

@@ -0,0 +1,11 @@
+import { MutableRefObject } from 'react';
+import { DependencyList } from './commonTypes';
+import { ViewDescriptorsSet, ViewRefSet } from '../ViewDescriptorsSet';
+import { AdapterWorkletFunction, AnimatedStyle, BasicWorkletFunction } from '../commonTypes';
+export interface AnimatedStyleResult {
+    viewDescriptors: ViewDescriptorsSet;
+    initial: AnimatedStyle;
+    viewsRef: ViewRefSet<any>;
+    animatedStyle?: MutableRefObject<AnimatedStyle>;
+}
+export declare function useAnimatedStyle<T extends AnimatedStyle>(updater: BasicWorkletFunction<T>, dependencies?: DependencyList, adapters?: AdapterWorkletFunction | AdapterWorkletFunction[]): AnimatedStyleResult;

package/lib/types/lib/reanimated2/hook/useDerivedValue.d.ts

@@ -0,0 +1,4 @@
+import { BasicWorkletFunction, SharedValue } from '../commonTypes';
+import { DependencyList } from './commonTypes';
+export declare type DerivedValue<T> = Readonly<SharedValue<T>>;
+export declare function useDerivedValue<T>(processor: BasicWorkletFunction<T>, dependencies: DependencyList): DerivedValue<T>;

package/lib/types/lib/reanimated2/hook/useSharedValue.d.ts

@@ -0,0 +1,2 @@
+import { SharedValue } from '../commonTypes';
+export declare function useSharedValue<T>(init: T): SharedValue<T>;

package/lib/types/lib/reanimated2/hook/utils.d.ts

@@ -0,0 +1,28 @@
+import { MutableRefObject } from 'react';
+import { AnimatedStyle, NativeEvent, NestedObjectValues, StyleProps, WorkletFunction, AnimationObject } from '../commonTypes';
+import WorkletEventHandler from '../WorkletEventHandler';
+import { Context, DependencyList } from './commonTypes';
+interface Handler<T, TContext extends Context> extends WorkletFunction {
+    (event: T, context: TContext): void;
+}
+interface Handlers<T, TContext extends Context> {
+    [key: string]: Handler<T, TContext> | undefined;
+}
+export interface UseHandlerContext<TContext extends Context> {
+    context: TContext;
+    doDependenciesDiffer: boolean;
+    useWeb: boolean;
+}
+export declare function useEvent<T extends NativeEvent<T>>(handler: (event: T) => void, eventNames?: string[], rebuild?: boolean): MutableRefObject<WorkletEventHandler<T> | null>;
+export declare function useHandler<T, TContext extends Context>(handlers: Handlers<T, TContext>, dependencies?: DependencyList): UseHandlerContext<TContext>;
+export declare function buildWorkletsHash(handlers: Record<string, WorkletFunction> | Array<WorkletFunction>): string;
+export declare function buildDependencies(dependencies: DependencyList, handlers: Record<string, WorkletFunction | undefined>): Array<unknown>;
+export declare function areDependenciesEqual(nextDeps: DependencyList, prevDeps: DependencyList): boolean;
+export declare function hasColorProps(updates: AnimatedStyle): boolean;
+export declare function parseColors(updates: AnimatedStyle): void;
+export declare function canApplyOptimalisation(upadterFn: WorkletFunction): number;
+export declare function isAnimated(prop: NestedObjectValues<AnimationObject>): boolean;
+export declare function styleDiff<T extends AnimatedStyle>(oldStyle: AnimatedStyle, newStyle: AnimatedStyle): Partial<T>;
+export declare function getStyleWithoutAnimations(newStyle: AnimatedStyle): StyleProps;
+export declare const validateAnimatedStyles: (styles: AnimatedStyle) => void;
+export {};

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

@@ -0,0 +1,12 @@
+export * from './core';
+export * from './hook';
+export * from './animation';
+export * from './interpolation';
+export * from './interpolateColor';
+export * from './Easing';
+export * from './NativeMethods';
+export * from './Colors';
+export * from './PropAdapters';
+export * from './layoutReanimation';
+export * from './utils';
+export * from './commonTypes';

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

@@ -0,0 +1,26 @@
+import { SharedValue } from './commonTypes';
+interface InterpolateRGB {
+    r: number[];
+    g: number[];
+    b: number[];
+    a: number[];
+}
+interface InterpolateHSV {
+    h: number[];
+    s: number[];
+    v: number[];
+}
+export declare const interpolateColor: (value: number, inputRange: readonly number[], outputRange: readonly (string | number)[], colorSpace?: 'RGB' | 'HSV') => string | number;
+export declare enum ColorSpace {
+    RGB = 0,
+    HSV = 1
+}
+export interface InterpolateConfig {
+    inputRange: readonly number[];
+    outputRange: readonly (string | number)[];
+    colorSpace: ColorSpace;
+    cache: SharedValue<InterpolateRGB | InterpolateHSV | null>;
+}
+export declare function useInterpolateConfig(inputRange: readonly number[], outputRange: readonly (string | number)[], colorSpace?: ColorSpace): SharedValue<InterpolateConfig>;
+export declare const interpolateSharableColor: (value: number, interpolateConfig: SharedValue<InterpolateConfig>) => string | number;
+export {};

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

@@ -0,0 +1,14 @@
+export declare enum Extrapolation {
+    IDENTITY = "identity",
+    CLAMP = "clamp",
+    EXTEND = "extend"
+}
+export interface InterpolatedNode {
+    __nodeId: number;
+}
+export interface ExtrapolationConfig {
+    extrapolateLeft?: Extrapolation | string;
+    extrapolateRight?: Extrapolation | string;
+}
+export declare type ExtrapolationType = ExtrapolationConfig | Extrapolation | string | undefined;
+export declare function interpolate(x: number | InterpolatedNode, input: readonly number[], output: readonly number[], type?: ExtrapolationType): number;

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

@@ -0,0 +1,12 @@
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            toHaveAnimatedStyle(style: Record<string, unknown>[] | Record<string, unknown>): R;
+        }
+    }
+}
+export declare const withReanimatedTimer: (animatonTest: any) => void;
+export declare const advanceAnimationByTime: (time?: number) => void;
+export declare const advanceAnimationByFrame: (count: any) => void;
+export declare const setUpTests: (userConfig?: {}) => void;
+export declare const getAnimatedStyle: (received: any) => {};