react-native-reanimated 2.16.0 → 2.17.0

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

@@ -0,0 +1,22 @@
+import { SharedValue, SensorValue3D, SensorValueRotation, AnimatedKeyboardInfo } 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;
+    subscribeForKeyboardEvents(keyboardEventData: AnimatedKeyboardInfo): number;
+    unsubscribeFromKeyboardEvents(listenerId: number): 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/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,99 @@
+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>;
+export declare type ShadowNodeWrapper = object;
+export declare enum KeyboardState {
+    UNKNOWN = 0,
+    OPENING = 1,
+    OPEN = 2,
+    CLOSING = 3,
+    CLOSED = 4
+}
+export declare type AnimatedKeyboardInfo = {
+    height: SharedValue<number>;
+    state: SharedValue<KeyboardState>;
+};
+export interface MeasuredDimensions {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    pageX: number;
+    pageY: number;
+}

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/Image.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const AnimatedImage: import("react").ComponentType<import("../../createAnimatedComponent").AnimatedComponentProps<import("../../createAnimatedComponent").InitialComponentProps>>;
+export default AnimatedImage;

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

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const AnimatedScrollView: import("react").ComponentType<import("../../createAnimatedComponent").AnimatedComponentProps<import("../../createAnimatedComponent").InitialComponentProps>>;
+export default AnimatedScrollView;

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

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const AnimatedText: import("react").ComponentType<import("../../createAnimatedComponent").AnimatedComponentProps<import("../../createAnimatedComponent").InitialComponentProps>>;
+export default AnimatedText;

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

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const AnimatedView: import("react").ComponentType<import("../../createAnimatedComponent").AnimatedComponentProps<import("../../createAnimatedComponent").InitialComponentProps>>;
+export default AnimatedView;

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/frameCallback/FrameCallbackRegistryJS.d.ts

@@ -0,0 +1,8 @@
+import { FrameInfo } from './FrameCallbackRegistryUI';
+export default class FrameCallbackRegistryJS {
+    private nextCallbackId;
+    constructor();
+    registerFrameCallback(callback: (frameInfo: FrameInfo) => void): number;
+    unregisterFrameCallback(callbackId: number): void;
+    manageStateFrameCallback(callbackId: number, state: boolean): void;
+}

package/lib/types/lib/reanimated2/frameCallback/FrameCallbackRegistryUI.d.ts

@@ -0,0 +1,20 @@
+declare type CallbackDetails = {
+    callback: (frameInfo: FrameInfo) => void;
+    startTime: number | null;
+};
+export declare type FrameInfo = {
+    timestamp: number;
+    timeSincePreviousFrame: number | null;
+    timeSinceFirstFrame: number;
+};
+export interface FrameCallbackRegistryUI {
+    frameCallbackRegistry: Map<number, CallbackDetails>;
+    activeFrameCallbacks: Set<number>;
+    previousFrameTimestamp: number | null;
+    runCallbacks: () => void;
+    registerFrameCallback: (callback: (frameInfo: FrameInfo) => void, callbackId: number) => void;
+    unregisterFrameCallback: (callbackId: number) => void;
+    manageStateFrameCallback: (callbackId: number, state: boolean) => void;
+}
+export declare const prepareUIRegistry: () => void;
+export {};

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,14 @@
+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';
+export { useFrameCallback } from './useFrameCallback';
+export type { FrameCallback } from './useFrameCallback';
+export { useAnimatedKeyboard } from './useAnimatedKeyboard';
+export { useScrollViewOffset } from './useScrollViewOffset';

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/useAnimatedKeyboard.d.ts

@@ -0,0 +1,2 @@
+import { AnimatedKeyboardInfo } from '../commonTypes';
+export declare function useAnimatedKeyboard(): AnimatedKeyboardInfo;

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,20 @@
+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;
+}
+export 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>>;

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

@@ -0,0 +1,18 @@
+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 | 'auto';
+};
+export declare type AnimatedSensor = {
+    sensor: SensorValue3D | SensorValueRotation | null;
+    unregister: () => void;
+    isAvailable: boolean;
+    config: SensorConfig;
+};
+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/useFrameCallback.d.ts

@@ -0,0 +1,7 @@
+import { FrameInfo } from '../frameCallback/FrameCallbackRegistryUI';
+export declare type FrameCallback = {
+    setActive: (isActive: boolean) => void;
+    isActive: boolean;
+    callbackId: number;
+};
+export declare function useFrameCallback(callback: (frameInfo: FrameInfo) => void, autostart?: boolean): FrameCallback;

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

@@ -0,0 +1,4 @@
+import { RefObject } from 'react';
+import type Animated from 'react-native-reanimated';
+import { SharedValue } from '../commonTypes';
+export declare function useScrollViewOffset(aref: RefObject<Animated.ScrollView>): SharedValue<number>;

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