react-native-reanimated 2.4.1 → 2.7.0

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,79 @@
+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;
+}
+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) => {};

package/lib/types/lib/reanimated2/js-reanimated/JSReanimated.d.ts

@@ -0,0 +1,30 @@
+import MapperRegistry from './MapperRegistry';
+import MutableValue from './MutableValue';
+import { NativeReanimated } from '../NativeReanimated/NativeReanimated';
+import { Timestamp, NestedObjectValues } from '../commonTypes';
+export default class JSReanimated extends NativeReanimated {
+    _valueSetter?: <T>(value: T) => void;
+    _renderRequested: boolean;
+    _mapperRegistry: MapperRegistry<any>;
+    _frames: ((timestamp: Timestamp) => void)[];
+    timeProvider: {
+        now: () => number;
+    };
+    constructor();
+    pushFrame(frame: (timestamp: Timestamp) => void): void;
+    getTimestamp(): number;
+    maybeRequestRender(): void;
+    _onRender(timestampMs: number): void;
+    installCoreFunctions(valueSetter: <T>(value: T) => void): void;
+    makeShareable<T>(value: T): T;
+    makeMutable<T>(value: T): MutableValue<T>;
+    makeRemote<T>(object?: {}): T;
+    startMapper(mapper: () => void, inputs?: NestedObjectValues<MutableValue<unknown>>[], outputs?: NestedObjectValues<MutableValue<unknown>>[]): number;
+    stopMapper(mapperId: number): void;
+    registerEventHandler<T>(_: string, __: (event: T) => void): string;
+    unregisterEventHandler(_: string): void;
+    enableLayoutAnimations(): void;
+    registerSensor(): number;
+    unregisterSensor(): void;
+    jestResetModule(): void;
+}

package/lib/types/lib/reanimated2/js-reanimated/Mapper.d.ts

@@ -0,0 +1,14 @@
+import { NestedObjectValues } from '../commonTypes';
+import { JSReanimated } from './commonTypes';
+import MutableValue from './MutableValue';
+export default class Mapper<T> {
+    static MAPPER_ID: number;
+    id: number;
+    inputs: MutableValue<T>[];
+    outputs: MutableValue<T>[];
+    mapper: () => void;
+    dirty: boolean;
+    constructor(module: JSReanimated, mapper: () => void, inputs?: NestedObjectValues<MutableValue<T>>[], outputs?: NestedObjectValues<MutableValue<T>>[]);
+    execute(): void;
+    extractMutablesFromArray<T>(array: NestedObjectValues<MutableValue<T>>): MutableValue<T>[];
+}

package/lib/types/lib/reanimated2/js-reanimated/MapperRegistry.d.ts

@@ -0,0 +1,14 @@
+import { JSReanimated } from './commonTypes';
+import Mapper from './Mapper';
+export default class MapperRegistry<T> {
+    sortedMappers: Mapper<T>[];
+    mappers: Map<number, Mapper<T>>;
+    _module: JSReanimated;
+    updatedSinceLastExecute: boolean;
+    constructor(module: JSReanimated);
+    startMapper(mapper: Mapper<T>): number;
+    stopMapper(id: number): void;
+    execute(): void;
+    updateOrder(): void;
+    get needRunOnRender(): boolean;
+}

package/lib/types/lib/reanimated2/js-reanimated/MutableValue.d.ts

@@ -0,0 +1,14 @@
+export default class MutableValue<T> {
+    static MUTABLE_ID: number;
+    _id: number;
+    _value: T;
+    _setter: (value: T) => void;
+    _animation: null;
+    _listeners: (() => void)[];
+    constructor(value: T, setter: (value: T) => void);
+    get value(): T;
+    set value(nextValue: T);
+    _setValue(newValue: T): void;
+    addListener(listener: () => void): void;
+    _triggerListener(): void;
+}

package/lib/types/lib/reanimated2/js-reanimated/commonTypes.d.ts

@@ -0,0 +1,44 @@
+import { Timestamp, NestedObjectValues } from '../commonTypes';
+import MutableValue from './MutableValue';
+export interface Mapper<T> {
+    MAPPER_ID?: number;
+    id: number;
+    inputs: MutableValue<T>[];
+    outputs: MutableValue<T>[];
+    mapper: () => void;
+    dirty: boolean;
+    execute(): void;
+    extractMutablesFromArray<T>(array: NestedObjectValues<MutableValue<T>>): MutableValue<T>[];
+}
+export interface MapperRegistry<T> {
+    sortedMappers: Mapper<T>[];
+    mappers: Map<number, Mapper<T>>;
+    _module: JSReanimated;
+    updatedSinceLastExecute: boolean;
+    startMapper(mapper: Mapper<T>): number;
+    stopMapper(id: number): void;
+    execute(): void;
+    updateOrder(): void;
+}
+export interface JSReanimated {
+    _valueSetter?: <T>(value: T) => void;
+    _renderRequested: boolean;
+    _mapperRegistry: MapperRegistry<any>;
+    _frames: ((timestamp: Timestamp) => void)[];
+    timeProvider: {
+        now: () => number;
+    };
+    pushFrame(frame: (timestamp: Timestamp) => void): void;
+    getTimestamp(): number;
+    maybeRequestRender(): void;
+    _onRender(timestampMs: number): void;
+    installCoreFunctions(valueSetter: <T>(value: T) => void): void;
+    makeShareable<T>(value: T): T;
+    makeMutable<T>(value: T): MutableValue<T>;
+    makeRemote<T>(object: Record<string, any>): T;
+    startMapper(mapper: () => void, inputs: NestedObjectValues<MutableValue<unknown>>[], outputs: NestedObjectValues<MutableValue<unknown>>[]): number;
+    stopMapper(mapperId: number): void;
+    registerEventHandler<T>(_: string, __: (event: T) => void): string;
+    unregisterEventHandler(_: string): void;
+    enableLayoutAnimations(): void;
+}

package/lib/types/lib/reanimated2/js-reanimated/index.d.ts

@@ -0,0 +1,15 @@
+import JSReanimated from './JSReanimated';
+import { AnimatedStyle, StyleProps } from '../commonTypes';
+declare const reanimatedJS: JSReanimated;
+interface JSReanimatedComponent {
+    previousStyle: StyleProps;
+    setNativeProps: (style: StyleProps) => void;
+    props: Record<string, string | number>;
+    _touchableNode: {
+        setAttribute: (key: string, props: unknown) => void;
+    };
+}
+export declare const _updatePropsJS: (updates: StyleProps | AnimatedStyle, viewRef: {
+    _component?: JSReanimatedComponent;
+}) => void;
+export default reanimatedJS;

package/lib/types/lib/reanimated2/layoutReanimation/LayoutAnimationRepository.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/types/lib/reanimated2/layoutReanimation/animationBuilder/BaseAnimationBuilder.d.ts

@@ -0,0 +1,22 @@
+import { EntryExitAnimationFunction, AnimationFunction, LayoutAnimationFunction } from './commonTypes';
+export declare class BaseAnimationBuilder {
+    durationV?: number;
+    delayV?: number;
+    randomizeDelay: boolean;
+    callbackV?: (finished: boolean) => void;
+    static createInstance: () => BaseAnimationBuilder;
+    build: () => EntryExitAnimationFunction | LayoutAnimationFunction;
+    static duration(durationMs: number): BaseAnimationBuilder;
+    duration(durationMs: number): BaseAnimationBuilder;
+    static delay(delayMs: number): BaseAnimationBuilder;
+    delay(delayMs: number): BaseAnimationBuilder;
+    static withCallback(callback: (finished: boolean) => void): BaseAnimationBuilder;
+    withCallback(callback: (finsihed: boolean) => void): BaseAnimationBuilder;
+    static getDuration(): number;
+    getDuration(): number;
+    static randomDelay(): BaseAnimationBuilder;
+    randomDelay(): BaseAnimationBuilder;
+    getDelay(): number;
+    getDelayFunction(): AnimationFunction;
+    static build(): EntryExitAnimationFunction | LayoutAnimationFunction;
+}

package/lib/types/lib/reanimated2/layoutReanimation/animationBuilder/ComplexAnimationBuilder.d.ts

@@ -0,0 +1,38 @@
+import { AnimationFunction, LayoutAnimationAndConfig } from './commonTypes';
+import { EasingFn } from '../../Easing';
+import { BaseAnimationBuilder } from './BaseAnimationBuilder';
+import { StyleProps } from '../../commonTypes';
+export declare class ComplexAnimationBuilder extends BaseAnimationBuilder {
+    easingV?: EasingFn;
+    rotateV?: string;
+    type?: AnimationFunction;
+    dampingV?: number;
+    massV?: number;
+    stiffnessV?: number;
+    overshootClampingV?: number;
+    restDisplacementThresholdV?: number;
+    restSpeedThresholdV?: number;
+    initialValues?: StyleProps;
+    static createInstance: () => ComplexAnimationBuilder;
+    static easing(easingFunction: EasingFn): ComplexAnimationBuilder;
+    easing(easingFunction: EasingFn): ComplexAnimationBuilder;
+    static rotate(degree: string): ComplexAnimationBuilder;
+    rotate(degree: string): ComplexAnimationBuilder;
+    static springify(): ComplexAnimationBuilder;
+    springify(): ComplexAnimationBuilder;
+    static damping(damping: number): ComplexAnimationBuilder;
+    damping(damping: number): ComplexAnimationBuilder;
+    static mass(mass: number): ComplexAnimationBuilder;
+    mass(mass: number): ComplexAnimationBuilder;
+    static stiffness(stiffness: number): ComplexAnimationBuilder;
+    stiffness(stiffness: number): ComplexAnimationBuilder;
+    static overshootClamping(overshootClamping: number): ComplexAnimationBuilder;
+    overshootClamping(overshootClamping: number): ComplexAnimationBuilder;
+    static restDisplacementThreshold(restDisplacementThreshold: number): ComplexAnimationBuilder;
+    restDisplacementThreshold(restDisplacementThreshold: number): ComplexAnimationBuilder;
+    static restSpeedThreshold(restSpeedThreshold: number): ComplexAnimationBuilder;
+    restSpeedThreshold(restSpeedThreshold: number): ComplexAnimationBuilder;
+    static withInitialValues(values: StyleProps): BaseAnimationBuilder;
+    withInitialValues(values: StyleProps): BaseAnimationBuilder;
+    getAnimationAndConfig(): LayoutAnimationAndConfig;
+}

package/lib/types/lib/reanimated2/layoutReanimation/animationBuilder/Keyframe.d.ts

@@ -0,0 +1,25 @@
+import { EasingFn } from '../../Easing';
+import { EntryExitAnimationFunction, IEntryExitAnimationBuilder, KeyframeProps } from './commonTypes';
+import { StyleProps } from '../../commonTypes';
+export interface KeyframePoint {
+    duration: number;
+    value: number | string;
+    easing?: EasingFn;
+}
+export interface ParsedKeyframesDefinition {
+    initialValues: StyleProps;
+    keyframes: Record<string, KeyframePoint[]>;
+}
+export declare class Keyframe implements IEntryExitAnimationBuilder {
+    durationV?: number;
+    delayV?: number;
+    callbackV?: (finished: boolean) => void;
+    definitions: Record<string, KeyframeProps>;
+    constructor(definitions: Record<string, KeyframeProps>);
+    private parseDefinitions;
+    duration(durationMs: number): Keyframe;
+    delay(delayMs: number): Keyframe;
+    withCallback(callback: (finsihed: boolean) => void): Keyframe;
+    private getDelayFunction;
+    build: () => EntryExitAnimationFunction;
+}