react-native-reanimated 2.5.0 → 2.6.0

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

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

@@ -0,0 +1,77 @@
+import { EasingFn } from '../../Easing';
+import { StyleProps } from '../../commonTypes';
+export interface KeyframeProps extends StyleProps {
+    easing?: EasingFn;
+    [key: string]: any;
+}
+export declare type LayoutAnimation = {
+    initialValues: StyleProps;
+    animations: StyleProps;
+    callback?: (finished: boolean) => void;
+};
+export declare type AnimationFunction = (a?: any, b?: any, c?: any) => any;
+export interface EntryAnimationsValues {
+    targetOriginX: number;
+    targetOriginY: number;
+    targetWidth: number;
+    targetHeight: number;
+    targetGlobalOriginX: number;
+    targetGlobalOriginY: number;
+}
+export interface ExitAnimationsValues {
+    currentOriginX: number;
+    currentOriginY: number;
+    currentWidth: number;
+    currentHeight: number;
+    currentGlobalOriginX: number;
+    currentGlobalOriginY: number;
+}
+export declare type EntryExitAnimationFunction = (targetValues: EntryAnimationsValues | ExitAnimationsValues) => LayoutAnimation;
+export declare type AnimationConfigFunction<T> = (targetValues: T) => LayoutAnimation;
+export interface LayoutAnimationsValues {
+    currentOriginX: number;
+    currentOriginY: number;
+    currentWidth: number;
+    currentHeight: number;
+    currentGlobalOriginX: number;
+    currentGlobalOriginY: number;
+    targetOriginX: number;
+    targetOriginY: number;
+    targetWidth: number;
+    targetHeight: number;
+    targetGlobalOriginX: number;
+    targetGlobalOriginY: number;
+    windowWidth: number;
+    windowHeight: number;
+}
+export declare type LayoutAnimationFunction = (targetValues: LayoutAnimationsValues) => LayoutAnimation;
+export interface ILayoutAnimationBuilder {
+    build: () => LayoutAnimationFunction;
+}
+export interface BaseLayoutAnimationConfig {
+    duration?: number;
+    easing?: EasingFn;
+    type?: AnimationFunction;
+    damping?: number;
+    mass?: number;
+    stiffness?: number;
+    overshootClamping?: number;
+    restDisplacementThreshold?: number;
+    restSpeedThreshold?: number;
+}
+export interface BaseBuilderAnimationConfig extends BaseLayoutAnimationConfig {
+    rotate?: number | string;
+}
+export declare type LayoutAnimationAndConfig = [
+    AnimationFunction,
+    BaseBuilderAnimationConfig
+];
+export interface IEntryExitAnimationBuilder {
+    build: () => EntryExitAnimationFunction;
+}
+export interface IEntryAnimationBuilder {
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export interface IExitAnimationBuilder {
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}

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

@@ -0,0 +1,4 @@
+export { BaseAnimationBuilder } from './BaseAnimationBuilder';
+export { ComplexAnimationBuilder } from './ComplexAnimationBuilder';
+export { Keyframe } from './Keyframe';
+export { LayoutAnimation, AnimationFunction, EntryAnimationsValues, ExitAnimationsValues, EntryExitAnimationFunction, AnimationConfigFunction, IEntryAnimationBuilder, IExitAnimationBuilder, LayoutAnimationsValues, LayoutAnimationFunction, ILayoutAnimationBuilder, BaseLayoutAnimationConfig, BaseBuilderAnimationConfig, LayoutAnimationAndConfig, IEntryExitAnimationBuilder, } from './commonTypes';

package/lib/types/lib/reanimated2/layoutReanimation/defaultAnimations/Bounce.d.ts

@@ -0,0 +1,62 @@
+import { EntryExitAnimationFunction, IEntryExitAnimationBuilder } from '../animationBuilder/commonTypes';
+import { ComplexAnimationBuilder } from '../animationBuilder/ComplexAnimationBuilder';
+export declare class BounceIn extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): BounceIn;
+    static getDuration(): number;
+    getDuration(): number;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class BounceInDown extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): BounceInDown;
+    static getDuration(): number;
+    getDuration(): number;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class BounceInUp extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): BounceInUp;
+    static getDuration(): number;
+    getDuration(): number;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class BounceInLeft extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): BounceInLeft;
+    static getDuration(): number;
+    getDuration(): number;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class BounceInRight extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): BounceInRight;
+    static getDuration(): number;
+    getDuration(): number;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class BounceOut extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): BounceOut;
+    static getDuration(): number;
+    getDuration(): number;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class BounceOutDown extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): BounceOutDown;
+    static getDuration(): number;
+    getDuration(): number;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class BounceOutUp extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): BounceOutUp;
+    static getDuration(): number;
+    getDuration(): number;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class BounceOutLeft extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): BounceOutRight;
+    static getDuration(): number;
+    getDuration(): number;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class BounceOutRight extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): BounceOutRight;
+    static getDuration(): number;
+    getDuration(): number;
+    build: () => EntryExitAnimationFunction;
+}

package/lib/types/lib/reanimated2/layoutReanimation/defaultAnimations/Default.d.ts

@@ -0,0 +1,4 @@
+import { LayoutAnimationFunction, EntryAnimationsValues, ExitAnimationsValues, AnimationConfigFunction } from '../animationBuilder/commonTypes';
+export declare const DefaultLayout: LayoutAnimationFunction;
+export declare const DefaultEntering: AnimationConfigFunction<EntryAnimationsValues>;
+export declare const DefaultExiting: AnimationConfigFunction<ExitAnimationsValues>;

package/lib/types/lib/reanimated2/layoutReanimation/defaultAnimations/Fade.d.ts

@@ -0,0 +1,42 @@
+import { IEntryExitAnimationBuilder, EntryExitAnimationFunction } from '../animationBuilder/commonTypes';
+import { ComplexAnimationBuilder } from '../animationBuilder';
+export declare class FadeIn extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): FadeIn;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class FadeInRight extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): FadeInRight;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class FadeInLeft extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): FadeInLeft;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class FadeInUp extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): FadeInUp;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class FadeInDown extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): FadeInDown;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class FadeOut extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): FadeOut;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class FadeOutRight extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): FadeOutRight;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class FadeOutLeft extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): FadeOutLeft;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class FadeOutUp extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): FadeOutUp;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class FadeOutDown extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): FadeOutDown;
+    build: () => EntryExitAnimationFunction;
+}

package/lib/types/lib/reanimated2/layoutReanimation/defaultAnimations/Flip.d.ts

@@ -0,0 +1,50 @@
+import { IEntryExitAnimationBuilder, EntryExitAnimationFunction, EntryAnimationsValues, ExitAnimationsValues, AnimationConfigFunction, IEntryAnimationBuilder, IExitAnimationBuilder } from '../animationBuilder/commonTypes';
+import { ComplexAnimationBuilder } from '../animationBuilder';
+export declare class FlipInXUp extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): FlipInXUp;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class FlipInYLeft extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): FlipInYLeft;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class FlipInXDown extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): FlipInXDown;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class FlipInYRight extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): FlipInYRight;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class FlipInEasyX extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): FlipInEasyX;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class FlipInEasyY extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): FlipInEasyY;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class FlipOutXUp extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): FlipOutXUp;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class FlipOutYLeft extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): FlipOutYLeft;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class FlipOutXDown extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): FlipOutXDown;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class FlipOutYRight extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): FlipOutYRight;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class FlipOutEasyX extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): FlipOutEasyX;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class FlipOutEasyY extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): FlipOutEasyY;
+    build: () => EntryExitAnimationFunction;
+}

package/lib/types/lib/reanimated2/layoutReanimation/defaultAnimations/Lightspeed.d.ts

@@ -0,0 +1,18 @@
+import { ComplexAnimationBuilder } from '../animationBuilder';
+import { EntryExitAnimationFunction, IEntryExitAnimationBuilder } from '../animationBuilder/commonTypes';
+export declare class LightSpeedInRight extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): LightSpeedInRight;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class LightSpeedInLeft extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): LightSpeedInLeft;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class LightSpeedOutRight extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): LightSpeedOutRight;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class LightSpeedOutLeft extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): LightSpeedOutLeft;
+    build: () => EntryExitAnimationFunction;
+}

package/lib/types/lib/reanimated2/layoutReanimation/defaultAnimations/Pinwheel.d.ts

@@ -0,0 +1,10 @@
+import { ComplexAnimationBuilder } from '../animationBuilder';
+import { EntryExitAnimationFunction, IEntryExitAnimationBuilder } from '../animationBuilder/commonTypes';
+export declare class PinwheelIn extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): PinwheelIn;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class PinwheelOut extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): PinwheelOut;
+    build: () => EntryExitAnimationFunction;
+}

package/lib/types/lib/reanimated2/layoutReanimation/defaultAnimations/Roll.d.ts

@@ -0,0 +1,18 @@
+import { ComplexAnimationBuilder } from '../animationBuilder';
+import { EntryExitAnimationFunction, IEntryExitAnimationBuilder } from '../animationBuilder/commonTypes';
+export declare class RollInLeft extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): RollInLeft;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class RollInRight extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): RollInRight;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class RollOutLeft extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): RollOutLeft;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class RollOutRight extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): RollOutRight;
+    build: () => EntryExitAnimationFunction;
+}

package/lib/types/lib/reanimated2/layoutReanimation/defaultAnimations/Rotate.d.ts

@@ -0,0 +1,34 @@
+import { ComplexAnimationBuilder } from '../animationBuilder';
+import { EntryAnimationsValues, ExitAnimationsValues, AnimationConfigFunction, IEntryAnimationBuilder, IExitAnimationBuilder } from '../animationBuilder/commonTypes';
+export declare class RotateInDownLeft extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): RotateInDownLeft;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class RotateInDownRight extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): RotateInDownRight;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class RotateInUpLeft extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): RotateInUpLeft;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class RotateInUpRight extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): RotateInUpRight;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class RotateOutDownLeft extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): RotateOutDownLeft;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class RotateOutDownRight extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): RotateOutDownRight;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class RotateOutUpLeft extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): RotateOutUpLeft;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class RotateOutUpRight extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): RotateOutUpRight;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}

package/lib/types/lib/reanimated2/layoutReanimation/defaultAnimations/Slide.d.ts

@@ -0,0 +1,34 @@
+import { EntryAnimationsValues, ExitAnimationsValues, AnimationConfigFunction, IEntryAnimationBuilder, IExitAnimationBuilder } from '../animationBuilder/commonTypes';
+import { ComplexAnimationBuilder } from '../animationBuilder';
+export declare class SlideInRight extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): SlideInRight;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class SlideInLeft extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): SlideInLeft;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class SlideOutRight extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): SlideOutRight;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class SlideOutLeft extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): SlideOutLeft;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class SlideInUp extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): SlideInUp;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class SlideInDown extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): SlideInDown;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class SlideOutUp extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): SlideOutUp;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class SlideOutDown extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): SlideOutDown;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}

package/lib/types/lib/reanimated2/layoutReanimation/defaultAnimations/Stretch.d.ts

@@ -0,0 +1,18 @@
+import { IEntryExitAnimationBuilder, EntryExitAnimationFunction } from '../animationBuilder/commonTypes';
+import { ComplexAnimationBuilder } from '../animationBuilder';
+export declare class StretchInX extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): StretchInX;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class StretchInY extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): StretchInY;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class StretchOutX extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): StretchOutX;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class StretchOutY extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): StretchOutY;
+    build: () => EntryExitAnimationFunction;
+}