@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1

package/lib/typescript/handlers/gestures/flingGesture.d.ts

@@ -0,0 +1,9 @@
+import { BaseGesture, BaseGestureConfig } from './gesture';
+import { FlingGestureConfig, FlingGestureHandlerEventPayload } from '../FlingGestureHandler';
+export declare class FlingGesture extends BaseGesture<FlingGestureHandlerEventPayload> {
+    config: BaseGestureConfig & FlingGestureConfig;
+    constructor();
+    numberOfPointers(pointers: number): this;
+    direction(direction: number): this;
+}
+export type FlingGestureType = InstanceType<typeof FlingGesture>;

package/lib/typescript/handlers/gestures/forceTouchGesture.d.ts

@@ -0,0 +1,15 @@
+import { BaseGestureConfig, ContinousBaseGesture } from './gesture';
+import { ForceTouchGestureConfig, ForceTouchGestureHandlerEventPayload } from '../ForceTouchGestureHandler';
+import { GestureUpdateEvent } from '../gestureHandlerCommon';
+export type ForceTouchGestureChangeEventPayload = {
+    forceChange: number;
+};
+export declare class ForceTouchGesture extends ContinousBaseGesture<ForceTouchGestureHandlerEventPayload, ForceTouchGestureChangeEventPayload> {
+    config: BaseGestureConfig & ForceTouchGestureConfig;
+    constructor();
+    minForce(force: number): this;
+    maxForce(force: number): this;
+    feedbackOnActivation(value: boolean): this;
+    onChange(callback: (event: GestureUpdateEvent<GestureUpdateEvent<ForceTouchGestureHandlerEventPayload & ForceTouchGestureChangeEventPayload>>) => void): this;
+}
+export type ForceTouchGestureType = InstanceType<typeof ForceTouchGesture>;

package/lib/typescript/handlers/gestures/gesture.d.ts

@@ -0,0 +1,110 @@
+import { FlingGestureHandlerEventPayload } from '../FlingGestureHandler';
+import { ForceTouchGestureHandlerEventPayload } from '../ForceTouchGestureHandler';
+import { HitSlop, CommonGestureConfig, GestureTouchEvent, GestureStateChangeEvent, GestureUpdateEvent, ActiveCursor } from '../gestureHandlerCommon';
+import { GestureStateManagerType } from './gestureStateManager';
+import { LongPressGestureHandlerEventPayload } from '../LongPressGestureHandler';
+import { PanGestureHandlerEventPayload } from '../PanGestureHandler';
+import { PinchGestureHandlerEventPayload } from '../PinchGestureHandler';
+import { RotationGestureHandlerEventPayload } from '../RotationGestureHandler';
+import { TapGestureHandlerEventPayload } from '../TapGestureHandler';
+import { NativeViewGestureHandlerPayload } from '../NativeViewGestureHandler';
+export type GestureType = BaseGesture<Record<string, unknown>> | BaseGesture<Record<string, never>> | BaseGesture<TapGestureHandlerEventPayload> | BaseGesture<PanGestureHandlerEventPayload> | BaseGesture<LongPressGestureHandlerEventPayload> | BaseGesture<RotationGestureHandlerEventPayload> | BaseGesture<PinchGestureHandlerEventPayload> | BaseGesture<FlingGestureHandlerEventPayload> | BaseGesture<ForceTouchGestureHandlerEventPayload> | BaseGesture<NativeViewGestureHandlerPayload>;
+export type GestureRef = number | GestureType | React.RefObject<GestureType | undefined> | React.RefObject<React.ComponentType | undefined>;
+export interface BaseGestureConfig extends CommonGestureConfig, Record<string, unknown> {
+    ref?: React.MutableRefObject<GestureType | undefined>;
+    requireToFail?: GestureRef[];
+    simultaneousWith?: GestureRef[];
+    blocksHandlers?: GestureRef[];
+    needsPointerData?: boolean;
+    manualActivation?: boolean;
+    runOnJS?: boolean;
+    testId?: string;
+    cancelsTouchesInView?: boolean;
+}
+type TouchEventHandlerType = (event: GestureTouchEvent, stateManager: GestureStateManagerType) => void;
+export type HandlerCallbacks<EventPayloadT extends Record<string, unknown>> = {
+    gestureId: number;
+    handlerTag: number;
+    onBegin?: (event: GestureStateChangeEvent<EventPayloadT>) => void;
+    onStart?: (event: GestureStateChangeEvent<EventPayloadT>) => void;
+    onEnd?: (event: GestureStateChangeEvent<EventPayloadT>, success: boolean) => void;
+    onFinalize?: (event: GestureStateChangeEvent<EventPayloadT>, success: boolean) => void;
+    onUpdate?: (event: GestureUpdateEvent<EventPayloadT>) => void;
+    onChange?: (event: any) => void;
+    onTouchesDown?: TouchEventHandlerType;
+    onTouchesMove?: TouchEventHandlerType;
+    onTouchesUp?: TouchEventHandlerType;
+    onTouchesCancelled?: TouchEventHandlerType;
+    changeEventCalculator?: (current: GestureUpdateEvent<Record<string, unknown>>, previous?: GestureUpdateEvent<Record<string, unknown>>) => GestureUpdateEvent<Record<string, unknown>>;
+    isWorklet: boolean[];
+};
+export declare const CALLBACK_TYPE: {
+    readonly UNDEFINED: 0;
+    readonly BEGAN: 1;
+    readonly START: 2;
+    readonly UPDATE: 3;
+    readonly CHANGE: 4;
+    readonly END: 5;
+    readonly FINALIZE: 6;
+    readonly TOUCHES_DOWN: 7;
+    readonly TOUCHES_MOVE: 8;
+    readonly TOUCHES_UP: 9;
+    readonly TOUCHES_CANCELLED: 10;
+};
+export type CALLBACK_TYPE = typeof CALLBACK_TYPE[keyof typeof CALLBACK_TYPE];
+export declare abstract class Gesture {
+    /**
+     * Return array of gestures, providing the same interface for creating and updating
+     * handlers, no matter which object was used to create gesture instance.
+     */
+    abstract toGestureArray(): GestureType[];
+    /**
+     * Assign handlerTag to the gesture instance and set ref.current (if a ref is set)
+     */
+    abstract initialize(): void;
+    /**
+     * Make sure that values of properties defining relations are arrays. Do any necessary
+     * preprocessing required to configure relations between handlers. Called just before
+     * updating the handler on the native side.
+     */
+    abstract prepare(): void;
+}
+export declare abstract class BaseGesture<EventPayloadT extends Record<string, unknown>> extends Gesture {
+    private gestureId;
+    handlerTag: number;
+    handlerName: string;
+    config: BaseGestureConfig;
+    handlers: HandlerCallbacks<EventPayloadT>;
+    constructor();
+    private addDependency;
+    withRef(ref: React.MutableRefObject<GestureType | undefined>): this;
+    protected isWorklet(callback: Function): boolean;
+    onBegin(callback: (event: GestureStateChangeEvent<EventPayloadT>) => void): this;
+    onStart(callback: (event: GestureStateChangeEvent<EventPayloadT>) => void): this;
+    onEnd(callback: (event: GestureStateChangeEvent<EventPayloadT>, success: boolean) => void): this;
+    onFinalize(callback: (event: GestureStateChangeEvent<EventPayloadT>, success: boolean) => void): this;
+    onTouchesDown(callback: TouchEventHandlerType): this;
+    onTouchesMove(callback: TouchEventHandlerType): this;
+    onTouchesUp(callback: TouchEventHandlerType): this;
+    onTouchesCancelled(callback: TouchEventHandlerType): this;
+    enabled(enabled: boolean): this;
+    shouldCancelWhenOutside(value: boolean): this;
+    hitSlop(hitSlop: HitSlop): this;
+    activeCursor(activeCursor: ActiveCursor): this;
+    runOnJS(runOnJS: boolean): this;
+    simultaneousWithExternalGesture(...gestures: Exclude<GestureRef, number>[]): this;
+    requireExternalGestureToFail(...gestures: Exclude<GestureRef, number>[]): this;
+    blocksExternalGesture(...gestures: Exclude<GestureRef, number>[]): this;
+    withTestId(id: string): this;
+    cancelsTouchesInView(value: boolean): this;
+    initialize(): void;
+    toGestureArray(): GestureType[];
+    prepare(): void;
+    get shouldUseReanimated(): boolean;
+}
+export declare abstract class ContinousBaseGesture<EventPayloadT extends Record<string, unknown>, EventChangePayloadT extends Record<string, unknown>> extends BaseGesture<EventPayloadT> {
+    onUpdate(callback: (event: GestureUpdateEvent<EventPayloadT>) => void): this;
+    onChange(callback: (event: GestureUpdateEvent<EventPayloadT & EventChangePayloadT>) => void): this;
+    manualActivation(manualActivation: boolean): this;
+}
+export {};

package/lib/typescript/handlers/gestures/gestureComposition.d.ts

@@ -0,0 +1,21 @@
+import { Gesture, GestureType } from './gesture';
+export declare class ComposedGesture extends Gesture {
+    protected gestures: Gesture[];
+    protected simultaneousGestures: GestureType[];
+    protected requireGesturesToFail: GestureType[];
+    constructor(...gestures: Gesture[]);
+    protected prepareSingleGesture(gesture: Gesture, simultaneousGestures: GestureType[], requireGesturesToFail: GestureType[]): void;
+    prepare(): void;
+    initialize(): void;
+    toGestureArray(): GestureType[];
+}
+export declare class SimultaneousGesture extends ComposedGesture {
+    prepare(): void;
+}
+export declare class ExclusiveGesture extends ComposedGesture {
+    prepare(): void;
+}
+export type ComposedGestureType = InstanceType<typeof ComposedGesture>;
+export type RaceGestureType = ComposedGestureType;
+export type SimultaneousGestureType = InstanceType<typeof SimultaneousGesture>;
+export type ExclusiveGestureType = InstanceType<typeof ExclusiveGesture>;

package/lib/typescript/handlers/gestures/gestureObjects.d.ts

@@ -0,0 +1,41 @@
+import { FlingGesture } from './flingGesture';
+import { ForceTouchGesture } from './forceTouchGesture';
+import { Gesture } from './gesture';
+import { ComposedGesture, ExclusiveGesture, SimultaneousGesture } from './gestureComposition';
+import { LongPressGesture } from './longPressGesture';
+import { PanGesture } from './panGesture';
+import { PinchGesture } from './pinchGesture';
+import { RotationGesture } from './rotationGesture';
+import { TapGesture } from './tapGesture';
+import { NativeGesture } from './nativeGesture';
+import { ManualGesture } from './manualGesture';
+import { HoverGesture } from './hoverGesture';
+export declare const GestureObjects: {
+    Tap: () => TapGesture;
+    Pan: () => PanGesture;
+    Pinch: () => PinchGesture;
+    Rotation: () => RotationGesture;
+    Fling: () => FlingGesture;
+    LongPress: () => LongPressGesture;
+    ForceTouch: () => ForceTouchGesture;
+    Native: () => NativeGesture;
+    Manual: () => ManualGesture;
+    Hover: () => HoverGesture;
+    /**
+     * Builds a composed gesture consisting of gestures provided as parameters.
+     * The first one that becomes active cancels the rest of gestures.
+     */
+    Race: (...gestures: Gesture[]) => ComposedGesture;
+    /**
+     * Builds a composed gesture that allows all base gestures to run simultaneously.
+     */
+    Simultaneous(...gestures: Gesture[]): SimultaneousGesture;
+    /**
+     * Builds a composed gesture where only one of the provided gestures can become active.
+     * Priority is decided through the order of gestures: the first one has higher priority
+     * than the second one, second one has higher priority than the third one, and so on.
+     * For example, to make a gesture that recognizes both single and double tap you need
+     * to call Exclusive(doubleTap, singleTap).
+     */
+    Exclusive(...gestures: Gesture[]): ExclusiveGesture;
+};

package/lib/typescript/handlers/gestures/gestureStateManager.d.ts

@@ -0,0 +1,9 @@
+export interface GestureStateManagerType {
+    begin: () => void;
+    activate: () => void;
+    fail: () => void;
+    end: () => void;
+}
+export declare const GestureStateManager: {
+    create(handlerTag: number): GestureStateManagerType;
+};

package/lib/typescript/handlers/gestures/gestureStateManager.web.d.ts

@@ -0,0 +1,4 @@
+import { GestureStateManagerType } from './gestureStateManager';
+export declare const GestureStateManager: {
+    create(handlerTag: number): GestureStateManagerType;
+};

package/lib/typescript/handlers/gestures/hoverGesture.d.ts

@@ -0,0 +1,32 @@
+import { BaseGestureConfig, ContinousBaseGesture } from './gesture';
+import { GestureUpdateEvent } from '../gestureHandlerCommon';
+export type HoverGestureHandlerEventPayload = {
+    x: number;
+    y: number;
+    absoluteX: number;
+    absoluteY: number;
+};
+export type HoverGestureChangeEventPayload = {
+    changeX: number;
+    changeY: number;
+};
+export declare enum HoverEffect {
+    NONE = 0,
+    LIFT = 1,
+    HIGHLIGHT = 2
+}
+export interface HoverGestureConfig {
+    hoverEffect?: HoverEffect;
+}
+export declare const hoverGestureHandlerProps: readonly ["hoverEffect"];
+export declare class HoverGesture extends ContinousBaseGesture<HoverGestureHandlerEventPayload, HoverGestureChangeEventPayload> {
+    config: BaseGestureConfig & HoverGestureConfig;
+    constructor();
+    /**
+     * Sets the visual hover effect.
+     * iOS only
+     */
+    effect(effect: HoverEffect): this;
+    onChange(callback: (event: GestureUpdateEvent<HoverGestureHandlerEventPayload & HoverGestureChangeEventPayload>) => void): this;
+}
+export type HoverGestureType = InstanceType<typeof HoverGesture>;

package/lib/typescript/handlers/gestures/longPressGesture.d.ts

@@ -0,0 +1,9 @@
+import { BaseGesture, BaseGestureConfig } from './gesture';
+import { LongPressGestureConfig, LongPressGestureHandlerEventPayload } from '../LongPressGestureHandler';
+export declare class LongPressGesture extends BaseGesture<LongPressGestureHandlerEventPayload> {
+    config: BaseGestureConfig & LongPressGestureConfig;
+    constructor();
+    minDuration(duration: number): this;
+    maxDistance(distance: number): this;
+}
+export type LongPressGestureType = InstanceType<typeof LongPressGesture>;

package/lib/typescript/handlers/gestures/manualGesture.d.ts

@@ -0,0 +1,7 @@
+import { GestureUpdateEvent } from '../gestureHandlerCommon';
+import { ContinousBaseGesture } from './gesture';
+export declare class ManualGesture extends ContinousBaseGesture<Record<string, never>, Record<string, never>> {
+    constructor();
+    onChange(callback: (event: GestureUpdateEvent<Record<string, never>>) => void): this;
+}
+export type ManualGestureType = InstanceType<typeof ManualGesture>;

package/lib/typescript/handlers/gestures/nativeGesture.d.ts

@@ -0,0 +1,9 @@
+import { BaseGestureConfig, BaseGesture } from './gesture';
+import { NativeViewGestureConfig, NativeViewGestureHandlerPayload } from '../NativeViewGestureHandler';
+export declare class NativeGesture extends BaseGesture<NativeViewGestureHandlerPayload> {
+    config: BaseGestureConfig & NativeViewGestureConfig;
+    constructor();
+    shouldActivateOnStart(value: boolean): this;
+    disallowInterruption(value: boolean): this;
+}
+export type NativeGestureType = InstanceType<typeof NativeGesture>;

package/lib/typescript/handlers/gestures/panGesture.d.ts

@@ -0,0 +1,26 @@
+import { BaseGestureConfig, ContinousBaseGesture } from './gesture';
+import { GestureUpdateEvent } from '../gestureHandlerCommon';
+import { PanGestureConfig, PanGestureHandlerEventPayload } from '../PanGestureHandler';
+export type PanGestureChangeEventPayload = {
+    changeX: number;
+    changeY: number;
+};
+export declare class PanGesture extends ContinousBaseGesture<PanGestureHandlerEventPayload, PanGestureChangeEventPayload> {
+    config: BaseGestureConfig & PanGestureConfig;
+    constructor();
+    activeOffsetY(offset: number | number[]): this;
+    activeOffsetX(offset: number | number[]): this;
+    failOffsetY(offset: number | number[]): this;
+    failOffsetX(offset: number | number[]): this;
+    minPointers(minPointers: number): this;
+    maxPointers(maxPointers: number): this;
+    minDistance(distance: number): this;
+    minVelocity(velocity: number): this;
+    minVelocityX(velocity: number): this;
+    minVelocityY(velocity: number): this;
+    averageTouches(value: boolean): this;
+    enableTrackpadTwoFingerGesture(value: boolean): this;
+    activateAfterLongPress(duration: number): this;
+    onChange(callback: (event: GestureUpdateEvent<PanGestureHandlerEventPayload & PanGestureChangeEventPayload>) => void): this;
+}
+export type PanGestureType = InstanceType<typeof PanGesture>;

package/lib/typescript/handlers/gestures/pinchGesture.d.ts

@@ -0,0 +1,11 @@
+import { ContinousBaseGesture } from './gesture';
+import { PinchGestureHandlerEventPayload } from '../PinchGestureHandler';
+import { GestureUpdateEvent } from '../gestureHandlerCommon';
+export type PinchGestureChangeEventPayload = {
+    scaleChange: number;
+};
+export declare class PinchGesture extends ContinousBaseGesture<PinchGestureHandlerEventPayload, PinchGestureChangeEventPayload> {
+    constructor();
+    onChange(callback: (event: GestureUpdateEvent<PinchGestureHandlerEventPayload & PinchGestureChangeEventPayload>) => void): this;
+}
+export type PinchGestureType = InstanceType<typeof PinchGesture>;

package/lib/typescript/handlers/gestures/reanimatedWrapper.d.ts

@@ -0,0 +1,14 @@
+import { ComponentClass } from 'react';
+import { GestureUpdateEvent, GestureStateChangeEvent } from '../gestureHandlerCommon';
+export interface SharedValue<T> {
+    value: T;
+}
+declare let Reanimated: {
+    default: {
+        createAnimatedComponent<P extends object>(component: ComponentClass<P>, options?: unknown): ComponentClass<P>;
+    };
+    useEvent: (callback: (event: GestureUpdateEvent | GestureStateChangeEvent) => void, events: string[], rebuild: boolean) => unknown;
+    useSharedValue: <T>(value: T) => SharedValue<T>;
+    setGestureState: (handlerTag: number, newState: number) => void;
+};
+export { Reanimated };

package/lib/typescript/handlers/gestures/rotationGesture.d.ts

@@ -0,0 +1,12 @@
+import { ContinousBaseGesture } from './gesture';
+import { RotationGestureHandlerEventPayload } from '../RotationGestureHandler';
+import { GestureUpdateEvent } from '../gestureHandlerCommon';
+type RotationGestureChangeEventPayload = {
+    rotationChange: number;
+};
+export declare class RotationGesture extends ContinousBaseGesture<RotationGestureHandlerEventPayload, RotationGestureChangeEventPayload> {
+    constructor();
+    onChange(callback: (event: GestureUpdateEvent<RotationGestureHandlerEventPayload & RotationGestureChangeEventPayload>) => void): this;
+}
+export type RotationGestureType = InstanceType<typeof RotationGesture>;
+export {};

package/lib/typescript/handlers/gestures/tapGesture.d.ts

@@ -0,0 +1,14 @@
+import { BaseGestureConfig, BaseGesture } from './gesture';
+import { TapGestureConfig, TapGestureHandlerEventPayload } from '../TapGestureHandler';
+export declare class TapGesture extends BaseGesture<TapGestureHandlerEventPayload> {
+    config: BaseGestureConfig & TapGestureConfig;
+    constructor();
+    minPointers(minPointers: number): this;
+    numberOfTaps(count: number): this;
+    maxDistance(maxDist: number): this;
+    maxDuration(duration: number): this;
+    maxDelay(delay: number): this;
+    maxDeltaX(delta: number): this;
+    maxDeltaY(delta: number): this;
+}
+export type TapGestureType = InstanceType<typeof TapGesture>;

package/lib/typescript/handlers/handlersRegistry.d.ts

@@ -0,0 +1,14 @@
+import { GestureType } from './gestures/gesture';
+import { GestureEvent, HandlerStateChangeEvent } from './gestureHandlerCommon';
+export declare const handlerIDToTag: Record<string, number>;
+export declare function getNextHandlerTag(): number;
+export declare function registerHandler(handlerTag: number, handler: GestureType, testID?: string): void;
+export declare function registerOldGestureHandler(handlerTag: number, handler: GestureHandlerCallbacks): void;
+export declare function unregisterHandler(handlerTag: number, testID?: string): void;
+export declare function findHandler(handlerTag: number): GestureType | undefined;
+export declare function findOldGestureHandler(handlerTag: number): GestureHandlerCallbacks | undefined;
+export declare function findHandlerByTestID(testID: string): import("./gestures/gesture").BaseGesture<Record<string, unknown>> | import("./gestures/gesture").BaseGesture<Record<string, never>> | import("./gestures/gesture").BaseGesture<import("./TapGestureHandler").TapGestureHandlerEventPayload> | import("./gestures/gesture").BaseGesture<import("./PanGestureHandler").PanGestureHandlerEventPayload> | import("./gestures/gesture").BaseGesture<import("./LongPressGestureHandler").LongPressGestureHandlerEventPayload> | import("./gestures/gesture").BaseGesture<import("./RotationGestureHandler").RotationGestureHandlerEventPayload> | import("./gestures/gesture").BaseGesture<import("./PinchGestureHandler").PinchGestureHandlerEventPayload> | import("./gestures/gesture").BaseGesture<import("./ForceTouchGestureHandler").ForceTouchGestureHandlerEventPayload> | import("./gestures/gesture").BaseGesture<import("./NativeViewGestureHandler").NativeViewGestureHandlerPayload> | null;
+export interface GestureHandlerCallbacks {
+    onGestureEvent: (event: GestureEvent<any>) => void;
+    onGestureStateChange: (event: HandlerStateChangeEvent<any>) => void;
+}

package/lib/typescript/index.d.ts

@@ -0,0 +1,52 @@
+export { Directions } from './Directions';
+export { State } from './State';
+export { default as gestureHandlerRootHOC } from './components/gestureHandlerRootHOC';
+export { default as GestureHandlerRootView } from './components/GestureHandlerRootView';
+export type { GestureEvent, HandlerStateChangeEvent, GestureEventPayload, HandlerStateChangeEventPayload, GestureTouchEvent, TouchData, GestureUpdateEvent, GestureStateChangeEvent, } from './handlers/gestureHandlerCommon';
+export type { GestureType } from './handlers/gestures/gesture';
+export type { TapGestureHandlerEventPayload, TapGestureHandlerProps, } from './handlers/TapGestureHandler';
+export type { ForceTouchGestureHandlerEventPayload, ForceTouchGestureHandlerProps, } from './handlers/ForceTouchGestureHandler';
+export type { ForceTouchGestureChangeEventPayload } from './handlers/gestures/forceTouchGesture';
+export type { LongPressGestureHandlerEventPayload, LongPressGestureHandlerProps, } from './handlers/LongPressGestureHandler';
+export type { PanGestureHandlerEventPayload, PanGestureHandlerProps, } from './handlers/PanGestureHandler';
+export type { PanGestureChangeEventPayload } from './handlers/gestures/panGesture';
+export type { PinchGestureHandlerEventPayload, PinchGestureHandlerProps, } from './handlers/PinchGestureHandler';
+export type { PinchGestureChangeEventPayload } from './handlers/gestures/pinchGesture';
+export type { RotationGestureHandlerEventPayload, RotationGestureHandlerProps, } from './handlers/RotationGestureHandler';
+export type { FlingGestureHandlerEventPayload, FlingGestureHandlerProps, } from './handlers/FlingGestureHandler';
+export { TapGestureHandler } from './handlers/TapGestureHandler';
+export { ForceTouchGestureHandler } from './handlers/ForceTouchGestureHandler';
+export { LongPressGestureHandler } from './handlers/LongPressGestureHandler';
+export { PanGestureHandler } from './handlers/PanGestureHandler';
+export { PinchGestureHandler } from './handlers/PinchGestureHandler';
+export { RotationGestureHandler } from './handlers/RotationGestureHandler';
+export { FlingGestureHandler } from './handlers/FlingGestureHandler';
+export { default as createNativeWrapper } from './handlers/createNativeWrapper';
+export type { NativeViewGestureHandlerPayload, NativeViewGestureHandlerProps, } from './handlers/NativeViewGestureHandler';
+export { GestureDetector } from './handlers/gestures/GestureDetector';
+export { GestureObjects as Gesture } from './handlers/gestures/gestureObjects';
+export type { TapGestureType as TapGesture } from './handlers/gestures/tapGesture';
+export type { PanGestureType as PanGesture } from './handlers/gestures/panGesture';
+export type { FlingGestureType as FlingGesture } from './handlers/gestures/flingGesture';
+export type { LongPressGestureType as LongPressGesture } from './handlers/gestures/longPressGesture';
+export type { PinchGestureType as PinchGesture } from './handlers/gestures/pinchGesture';
+export type { RotationGestureType as RotationGesture } from './handlers/gestures/rotationGesture';
+export type { ForceTouchGestureType as ForceTouchGesture } from './handlers/gestures/forceTouchGesture';
+export type { NativeGestureType as NativeGesture } from './handlers/gestures/nativeGesture';
+export type { ManualGestureType as ManualGesture } from './handlers/gestures/manualGesture';
+export type { HoverGestureType as HoverGesture } from './handlers/gestures/hoverGesture';
+export type { ComposedGestureType as ComposedGesture, RaceGestureType as RaceGesture, SimultaneousGestureType as SimultaneousGesture, ExclusiveGestureType as ExclusiveGesture, } from './handlers/gestures/gestureComposition';
+export type { GestureStateManagerType as GestureStateManager } from './handlers/gestures/gestureStateManager';
+export { NativeViewGestureHandler } from './handlers/NativeViewGestureHandler';
+export type { RawButtonProps, BaseButtonProps, RectButtonProps, BorderlessButtonProps, } from './components/GestureButtons';
+export { RawButton, BaseButton, RectButton, BorderlessButton, PureNativeButton, } from './components/GestureButtons';
+export type { TouchableHighlightProps, TouchableOpacityProps, TouchableWithoutFeedbackProps, } from './components/touchables';
+export { TouchableHighlight, TouchableNativeFeedback, TouchableOpacity, TouchableWithoutFeedback, } from './components/touchables';
+export { ScrollView, Switch, TextInput, DrawerLayoutAndroid, FlatList, RefreshControl, } from './components/GestureComponents';
+export { HoverEffect } from './handlers/gestures/hoverGesture';
+export type { GestureHandlerGestureEvent, GestureHandlerStateChangeEvent, GestureHandlerGestureEventNativeEvent, GestureHandlerStateChangeNativeEvent, NativeViewGestureHandlerGestureEvent, NativeViewGestureHandlerStateChangeEvent, TapGestureHandlerGestureEvent, TapGestureHandlerStateChangeEvent, ForceTouchGestureHandlerGestureEvent, ForceTouchGestureHandlerStateChangeEvent, LongPressGestureHandlerGestureEvent, LongPressGestureHandlerStateChangeEvent, PanGestureHandlerGestureEvent, PanGestureHandlerStateChangeEvent, PinchGestureHandlerGestureEvent, PinchGestureHandlerStateChangeEvent, RotationGestureHandlerGestureEvent, RotationGestureHandlerStateChangeEvent, FlingGestureHandlerGestureEvent, FlingGestureHandlerStateChangeEvent, NativeViewGestureHandlerProperties, TapGestureHandlerProperties, LongPressGestureHandlerProperties, PanGestureHandlerProperties, PinchGestureHandlerProperties, RotationGestureHandlerProperties, FlingGestureHandlerProperties, ForceTouchGestureHandlerProperties, RawButtonProperties, BaseButtonProperties, RectButtonProperties, BorderlessButtonProperties, } from './handlers/gestureHandlerTypesCompat';
+export type { SwipeableProps } from './components/Swipeable';
+export { default as Swipeable } from './components/Swipeable';
+export type { DrawerLayoutProps, DrawerPosition, DrawerState, DrawerType, DrawerLockMode, DrawerKeyboardDismissMode, } from './components/DrawerLayout';
+export { default as DrawerLayout } from './components/DrawerLayout';
+export { enableExperimentalWebImplementation, enableLegacyWebImplementation, } from './EnableNewWebImplementation';

package/lib/typescript/init.d.ts

@@ -0,0 +1,2 @@
+export declare function initialize(): void;
+export declare function maybeInitializeFabric(): void;

package/lib/typescript/jestUtils/index.d.ts

@@ -0,0 +1 @@
+export { getByGestureTestId, fireGestureHandler } from './jestUtils';

package/lib/typescript/jestUtils/jestUtils.d.ts

@@ -0,0 +1,28 @@
+import { ReactTestInstance } from 'react-test-renderer';
+import { FlingGestureHandler } from '../handlers/FlingGestureHandler';
+import { ForceTouchGestureHandler, ForceTouchGestureHandlerEventPayload } from '../handlers/ForceTouchGestureHandler';
+import { BaseGestureHandlerProps, GestureEvent, HandlerStateChangeEvent } from '../handlers/gestureHandlerCommon';
+import { FlingGesture } from '../handlers/gestures/flingGesture';
+import { ForceTouchGesture } from '../handlers/gestures/forceTouchGesture';
+import { BaseGesture, GestureType } from '../handlers/gestures/gesture';
+import { LongPressGesture } from '../handlers/gestures/longPressGesture';
+import { NativeGesture } from '../handlers/gestures/nativeGesture';
+import { PanGesture } from '../handlers/gestures/panGesture';
+import { PinchGesture } from '../handlers/gestures/pinchGesture';
+import { RotationGesture } from '../handlers/gestures/rotationGesture';
+import { TapGesture } from '../handlers/gestures/tapGesture';
+import { LongPressGestureHandler, LongPressGestureHandlerEventPayload } from '../handlers/LongPressGestureHandler';
+import { NativeViewGestureHandler, NativeViewGestureHandlerPayload } from '../handlers/NativeViewGestureHandler';
+import { PanGestureHandler, PanGestureHandlerEventPayload } from '../handlers/PanGestureHandler';
+import { PinchGestureHandler, PinchGestureHandlerEventPayload } from '../handlers/PinchGestureHandler';
+import { RotationGestureHandler, RotationGestureHandlerEventPayload } from '../handlers/RotationGestureHandler';
+import { TapGestureHandler, TapGestureHandlerEventPayload } from '../handlers/TapGestureHandler';
+type GestureHandlerTestEvent<TEventPayload extends Record<string, unknown> = Record<string, unknown>> = (GestureEvent<TEventPayload> | HandlerStateChangeEvent<TEventPayload>)['nativeEvent'];
+type AllGestures = TapGesture | PanGesture | LongPressGesture | RotationGesture | PinchGesture | FlingGesture | ForceTouchGesture | NativeGesture;
+type AllHandlers = TapGestureHandler | PanGestureHandler | LongPressGestureHandler | RotationGestureHandler | PinchGestureHandler | FlingGestureHandler | ForceTouchGestureHandler | NativeViewGestureHandler;
+type ClassComponentConstructor<P> = new (props: P) => React.Component<P, any, any>;
+type ExtractPayloadFromProps<T> = T extends BaseGestureHandlerProps<infer TPayload> ? TPayload : never;
+type ExtractConfig<T> = T extends BaseGesture<infer TGesturePayload> ? TGesturePayload : T extends ClassComponentConstructor<infer THandlerProps> ? ExtractPayloadFromProps<THandlerProps> : Record<string, unknown>;
+export declare function fireGestureHandler<THandler extends AllGestures | AllHandlers>(componentOrGesture: ReactTestInstance | GestureType, eventList?: Partial<GestureHandlerTestEvent<ExtractConfig<THandler>>>[]): void;
+export declare function getByGestureTestId(testID: string): BaseGesture<Record<string, unknown>> | BaseGesture<Record<string, never>> | BaseGesture<TapGestureHandlerEventPayload> | BaseGesture<PanGestureHandlerEventPayload> | BaseGesture<LongPressGestureHandlerEventPayload> | BaseGesture<RotationGestureHandlerEventPayload> | BaseGesture<PinchGestureHandlerEventPayload> | BaseGesture<ForceTouchGestureHandlerEventPayload> | BaseGesture<NativeViewGestureHandlerPayload>;
+export {};

package/lib/typescript/mocks.d.ts

@@ -0,0 +1,44 @@
+import { TouchableHighlight, TouchableNativeFeedback, TouchableOpacity, TouchableWithoutFeedback, ScrollView, FlatList, Switch, TextInput, DrawerLayoutAndroid, View } from 'react-native';
+declare const _default: {
+    readonly TouchableHighlight: typeof TouchableHighlight;
+    readonly TouchableNativeFeedback: typeof TouchableNativeFeedback;
+    readonly TouchableOpacity: typeof TouchableOpacity;
+    readonly TouchableWithoutFeedback: typeof TouchableWithoutFeedback;
+    readonly ScrollView: typeof ScrollView;
+    readonly FlatList: typeof FlatList;
+    readonly Switch: typeof Switch;
+    readonly TextInput: typeof TextInput;
+    readonly DrawerLayoutAndroid: typeof DrawerLayoutAndroid;
+    readonly NativeViewGestureHandler: typeof View;
+    readonly TapGestureHandler: typeof View;
+    readonly ForceTouchGestureHandler: typeof View;
+    readonly LongPressGestureHandler: typeof View;
+    readonly PinchGestureHandler: typeof View;
+    readonly RotationGestureHandler: typeof View;
+    readonly FlingGestureHandler: typeof View;
+    readonly RawButton: typeof TouchableNativeFeedback;
+    readonly BaseButton: typeof TouchableNativeFeedback;
+    readonly RectButton: typeof TouchableNativeFeedback;
+    readonly BorderlessButton: typeof TouchableNativeFeedback;
+    readonly PanGestureHandler: typeof View;
+    readonly attachGestureHandler: () => void;
+    readonly createGestureHandler: () => void;
+    readonly dropGestureHandler: () => void;
+    readonly updateGestureHandler: () => void;
+    readonly flushOperations: () => void;
+    readonly Directions: {
+        readonly RIGHT: 1;
+        readonly LEFT: 2;
+        readonly UP: 4;
+        readonly DOWN: 8;
+    };
+    readonly State: {
+        readonly UNDETERMINED: 0;
+        readonly FAILED: 1;
+        readonly BEGAN: 2;
+        readonly CANCELLED: 3;
+        readonly ACTIVE: 4;
+        readonly END: 5;
+    };
+};
+export default _default;

package/lib/typescript/specs/RNGestureHandlerButtonNativeComponent.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react-native/types/modules/codegen" />
+import type { Int32, WithDefault } from 'react-native/Libraries/Types/CodegenTypes';
+import type { ViewProps, ColorValue } from 'react-native';
+interface NativeProps extends ViewProps {
+    exclusive?: WithDefault<boolean, true>;
+    foreground?: boolean;
+    borderless?: boolean;
+    enabled?: WithDefault<boolean, true>;
+    rippleColor?: ColorValue;
+    rippleRadius?: Int32;
+    touchSoundDisabled?: WithDefault<boolean, false>;
+}
+declare const _default: import("react-native/Libraries/Utilities/codegenNativeComponent").NativeComponentType<NativeProps>;
+export default _default;

package/lib/typescript/specs/RNGestureHandlerRootViewNativeComponent.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react-native/types/modules/codegen" />
+import type { ViewProps } from 'react-native';
+interface NativeProps extends ViewProps {
+}
+declare const _default: import("react-native/Libraries/Utilities/codegenNativeComponent").NativeComponentType<NativeProps>;
+export default _default;

package/lib/typescript/typeUtils.d.ts

@@ -0,0 +1 @@
+export type ValueOf<T> = T[keyof T];

package/lib/typescript/utils.d.ts

@@ -0,0 +1,8 @@
+export declare function toArray<T>(object: T | T[]): T[];
+export type withPrevAndCurrentMapFn<T, Transformed> = (previous: Transformed | null, current: T) => Transformed;
+export declare function withPrevAndCurrent<T, Transformed>(array: T[], mapFn: withPrevAndCurrentMapFn<T, Transformed>): Transformed[];
+export declare function hasProperty(object: object, key: string): boolean;
+export declare function isJestEnv(): boolean;
+export declare function tagMessage(msg: string): string;
+export declare function isFabric(): boolean;
+export declare function isRemoteDebuggingEnabled(): boolean;

package/lib/typescript/web/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_TOUCH_SLOP = 15;
+export declare const Direction: {
+    RIGHT: number;
+    LEFT: number;
+    UP: number;
+    DOWN: number;
+};

package/lib/typescript/web/detectors/RotationGestureDetector.d.ts

@@ -0,0 +1,30 @@
+import { AdaptedEvent } from '../interfaces';
+import PointerTracker from '../tools/PointerTracker';
+export interface RotationGestureListener {
+    onRotationBegin: (detector: RotationGestureDetector) => boolean;
+    onRotation: (detector: RotationGestureDetector) => boolean;
+    onRotationEnd: (detector: RotationGestureDetector) => void;
+}
+export default class RotationGestureDetector implements RotationGestureListener {
+    onRotationBegin: (detector: RotationGestureDetector) => boolean;
+    onRotation: (detector: RotationGestureDetector) => boolean;
+    onRotationEnd: (detector: RotationGestureDetector) => void;
+    private currentTime;
+    private previousTime;
+    private previousAngle;
+    private rotation;
+    private anchorX;
+    private anchorY;
+    private isInProgress;
+    private keyPointers;
+    constructor(callbacks: RotationGestureListener);
+    private updateCurrent;
+    private finish;
+    private setKeyPointers;
+    onTouchEvent(event: AdaptedEvent, tracker: PointerTracker): boolean;
+    getTimeDelta(): number;
+    getAnchorX(): number;
+    getAnchorY(): number;
+    getRotation(): number;
+    reset(): void;
+}

package/lib/typescript/web/detectors/ScaleGestureDetector.d.ts

@@ -0,0 +1,29 @@
+import { AdaptedEvent } from '../interfaces';
+import PointerTracker from '../tools/PointerTracker';
+export interface ScaleGestureListener {
+    onScaleBegin: (detector: ScaleGestureDetector) => boolean;
+    onScale: (detector: ScaleGestureDetector) => boolean;
+    onScaleEnd: (detector: ScaleGestureDetector) => void;
+}
+export default class ScaleGestureDetector implements ScaleGestureListener {
+    onScaleBegin: (detector: ScaleGestureDetector) => boolean;
+    onScale: (detector: ScaleGestureDetector) => boolean;
+    onScaleEnd: (detector: ScaleGestureDetector) => void;
+    private focusX;
+    private focusY;
+    private currentSpan;
+    private prevSpan;
+    private initialSpan;
+    private currentTime;
+    private prevTime;
+    private inProgress;
+    private spanSlop;
+    private minSpan;
+    constructor(callbacks: ScaleGestureListener);
+    onTouchEvent(event: AdaptedEvent, tracker: PointerTracker): boolean;
+    getCurrentSpan(): number;
+    getFocusX(): number;
+    getFocusY(): number;
+    getTimeDelta(): number;
+    getScaleFactor(numOfPointers: number): number;
+}