react-native-gesture-handler

const Directions: {
    readonly RIGHT: 1;
    readonly LEFT: 2;
    readonly UP: 4;
    readonly DOWN: 8;
};

const DrawerLayoutAndroid: React.ForwardRefExoticComponent<any>;

const FlingGestureHandler: any;

const ForceTouchGestureHandler: any;

const Gesture: {
    Tap: () => TapGesture;
    Pan: () => PanGesture;
    Pinch: () => PinchGesture;
    Rotation: () => RotationGesture;
    Fling: () => FlingGesture;
    LongPress: () => LongPressGesture;
    ForceTouch: () => ForceTouchGesture;
    Native: () => NativeGesture;
    Manual: () => ManualGesture;
    Hover: () => HoverGesture;
    Race: (...gestures: Gesture[]) => ComposedGesture;
    Simultaneous(...gestures: Gesture[]): SimultaneousGesture;
    Exclusive(...gestures: Gesture[]): ExclusiveGesture;
};

const LongPressGestureHandler: any;

const NativeViewGestureHandler: any;

const PanGestureHandler: any;

const PinchGestureHandler: any;

const PureNativeButton: HostComponent<RawButtonProps>;

const RawButton: React.ForwardRefExoticComponent<any>;

const RefreshControl: React.ForwardRefExoticComponent<any>;

const RotationGestureHandler: any;

const ScrollView: React.ForwardRefExoticComponent<any>;

const State: {
    readonly UNDETERMINED: 0;
    readonly FAILED: 1;
    readonly BEGAN: 2;
    readonly CANCELLED: 3;
    readonly ACTIVE: 4;
    readonly END: 5;
};

const Switch: React.ForwardRefExoticComponent<any>;

const TapGestureHandler: any;

const TextInput: React.ForwardRefExoticComponent<any>;

const TouchableWithoutFeedback: React.ForwardRefExoticComponent<any>;

createNativeWrapper: <P>(
    Component: React.ComponentType<P>,
    config?: Readonly<NativeViewGestureHandlerProps>
) => React.ForwardRefExoticComponent<any>;

enableExperimentalWebImplementation: (_shouldEnable?: boolean) => void;

enableLegacyWebImplementation: (shouldUseLegacyImplementation?: boolean) => void;

FlatList: <ItemT = any>(
    props: React.PropsWithChildren<any>,
    ref: React.ForwardedRef<any>
) => ReactElement | null;

GestureDetector: (props: GestureDetectorProps) => React.JSX.Element;

gestureHandlerRootHOC: <P extends object>(
    Component: React.ComponentType<P>,
    containerStyles?: StyleProp<ViewStyle>
) => React.ComponentType<P>;

GestureHandlerRootView: ({
    style,
    ...rest
}: GestureHandlerRootViewProps) => React.JSX.Element;

type BaseButtonProperties = BaseButtonProps;

type BorderlessButtonProperties = BorderlessButtonProps;

type ComposedGestureType = InstanceType<typeof ComposedGesture>;

type Directions = (typeof Directions)[keyof typeof Directions];

type DrawerKeyboardDismissMode = 'none' | 'on-drag';

type DrawerLayoutAndroid = typeof DrawerLayoutAndroid & RNDrawerLayoutAndroid;

type DrawerLockMode = 'unlocked' | 'locked-closed' | 'locked-open';

type DrawerPosition = 'left' | 'right';

type DrawerState = 'Idle' | 'Dragging' | 'Settling';

type DrawerType = 'front' | 'back' | 'slide';

type ExclusiveGestureType = InstanceType<typeof ExclusiveGesture>;

type FlatList<ItemT = any> = typeof FlatList & RNFlatList<ItemT>;

type FlingGestureType = InstanceType<typeof FlingGesture>;

type FlingGestureHandler = typeof FlingGestureHandler;

type FlingGestureHandlerEventPayload = {
    x: number;
    y: number;
    absoluteX: number;
    absoluteY: number;
};

type FlingGestureHandlerGestureEvent = GestureEvent<FlingGestureHandlerEventPayload>;

type FlingGestureHandlerProperties = FlingGestureHandlerProps;

type FlingGestureHandlerStateChangeEvent =
    HandlerStateChangeEvent<FlingGestureHandlerEventPayload>;

type ForceTouchGestureType = InstanceType<typeof ForceTouchGesture>;

type ForceTouchGestureChangeEventPayload = {
    forceChange: number;
};

type ForceTouchGestureHandler = typeof ForceTouchGestureHandler & {
    forceTouchAvailable: boolean;
};

type ForceTouchGestureHandlerEventPayload = {
    x: number;
    y: number;
    absoluteX: number;
    absoluteY: number;
    /**
     * The pressure of a touch.
     */
    force: number;
};

type ForceTouchGestureHandlerGestureEvent =
    GestureEvent<ForceTouchGestureHandlerEventPayload>;

type ForceTouchGestureHandlerProperties = ForceTouchGestureHandlerProps;

type ForceTouchGestureHandlerStateChangeEvent =
    HandlerStateChangeEvent<ForceTouchGestureHandlerEventPayload>;

type GestureHandlerGestureEvent = GestureEvent;

type GestureHandlerGestureEventNativeEvent = GestureEventPayload;

type GestureHandlerStateChangeEvent = HandlerStateChangeEvent;

type GestureHandlerStateChangeNativeEvent = HandlerStateChangeEventPayload;

type GestureStateChangeEvent<
    GestureStateChangeEventPayloadT = Record<string, unknown>
> = HandlerStateChangeEventPayload & GestureStateChangeEventPayloadT;

type GestureTouchEvent = {
    handlerTag: number;
    numberOfTouches: number;
    state: ValueOf<typeof State>;
    eventType: TouchEventType;
    allTouches: TouchData[];
    changedTouches: TouchData[];
};

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

type GestureUpdateEvent<GestureEventPayloadT = Record<string, unknown>> =
    GestureEventPayload & GestureEventPayloadT;

type HoverGestureType = InstanceType<typeof HoverGesture>;

type LongPressGestureType = InstanceType<typeof LongPressGesture>;

type LongPressGestureHandler = typeof LongPressGestureHandler;

type LongPressGestureHandlerEventPayload = {
    /**
     * X coordinate, expressed in points, of the current position of the pointer
     * (finger or a leading pointer when there are multiple fingers placed)
     * relative to the view attached to the handler.
     */
    x: number;
    /**
     * Y coordinate, expressed in points, of the current position of the pointer
     * (finger or a leading pointer when there are multiple fingers placed)
     * relative to the view attached to the handler.
     */
    y: number;
    /**
     * X coordinate, expressed in points, of the current position of the pointer
     * (finger or a leading pointer when there are multiple fingers placed)
     * relative to the window. It is recommended to use `absoluteX` instead of
     * `x` in cases when the view attached to the handler can be transformed as an
     * effect of the gesture.
     */
    absoluteX: number;
    /**
     * Y coordinate, expressed in points, of the current position of the pointer
     * (finger or a leading pointer when there are multiple fingers placed)
     * relative to the window. It is recommended to use `absoluteY` instead of
     * `y` in cases when the view attached to the handler can be transformed as an
     * effect of the gesture.
     */
    absoluteY: number;
    /**
     * Duration of the long press (time since the start of the event), expressed
     * in milliseconds.
     */
    duration: number;
};

type LongPressGestureHandlerGestureEvent =
    GestureEvent<LongPressGestureHandlerEventPayload>;

type LongPressGestureHandlerProperties = LongPressGestureHandlerProps;

type LongPressGestureHandlerStateChangeEvent =
    HandlerStateChangeEvent<LongPressGestureHandlerEventPayload>;

type ManualGestureType = InstanceType<typeof ManualGesture>;

type NativeGestureType = InstanceType<typeof NativeGesture>;

type NativeViewGestureHandler = typeof NativeViewGestureHandler;

type NativeViewGestureHandlerGestureEvent =
    GestureEvent<NativeViewGestureHandlerPayload>;

type NativeViewGestureHandlerPayload = {
    /**
     * True if gesture was performed inside of containing view, false otherwise.
     */
    pointerInside: boolean;
};

type NativeViewGestureHandlerProperties = NativeViewGestureHandlerProps;

type NativeViewGestureHandlerStateChangeEvent =
    HandlerStateChangeEvent<NativeViewGestureHandlerPayload>;

type PanGestureType = InstanceType<typeof PanGesture>;

type PanGestureChangeEventPayload = {
    changeX: number;
    changeY: number;
};

type PanGestureHandler = typeof PanGestureHandler;

type PanGestureHandlerEventPayload = {
    /**
     * X coordinate of the current position of the pointer (finger or a leading
     * pointer when there are multiple fingers placed) relative to the view
     * attached to the handler. Expressed in point units.
     */
    x: number;
    /**
     * Y coordinate of the current position of the pointer (finger or a leading
     * pointer when there are multiple fingers placed) relative to the view
     * attached to the handler. Expressed in point units.
     */
    y: number;
    /**
     * X coordinate of the current position of the pointer (finger or a leading
     * pointer when there are multiple fingers placed) relative to the window.
     * The value is expressed in point units. It is recommended to use it instead
     * of `x` in cases when the original view can be transformed as an effect of
     * the gesture.
     */
    absoluteX: number;
    /**
     * Y coordinate of the current position of the pointer (finger or a leading
     * pointer when there are multiple fingers placed) relative to the window.
     * The value is expressed in point units. It is recommended to use it instead
     * of `y` in cases when the original view can be transformed as an
     * effect of the gesture.
     */
    absoluteY: number;
    /**
     * Translation of the pan gesture along X axis accumulated over the time of
     * the gesture. The value is expressed in the point units.
     */
    translationX: number;
    /**
     * Translation of the pan gesture along Y axis accumulated over the time of
     * the gesture. The value is expressed in the point units.
     */
    translationY: number;
    /**
     * Velocity of the pan gesture along the X axis in the current moment. The
     * value is expressed in point units per second.
     */
    velocityX: number;
    /**
     * Velocity of the pan gesture along the Y axis in the current moment. The
     * value is expressed in point units per second.
     */
    velocityY: number;
};

type PanGestureHandlerGestureEvent = GestureEvent<PanGestureHandlerEventPayload>;

type PanGestureHandlerProperties = PanGestureHandlerProps;

type PanGestureHandlerStateChangeEvent =
    HandlerStateChangeEvent<PanGestureHandlerEventPayload>;

type PinchGestureType = InstanceType<typeof PinchGesture>;

type PinchGestureChangeEventPayload = {
    scaleChange: number;
};