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

package/lib/typescript/components/touchables/TouchableOpacity.d.ts

@@ -0,0 +1,25 @@
+import { Animated, TouchableOpacityProps as RNTouchableOpacityProps } from 'react-native';
+import { GenericTouchableProps } from './GenericTouchable';
+import * as React from 'react';
+import { Component } from 'react';
+export type TouchableOpacityProps = RNTouchableOpacityProps & GenericTouchableProps & {
+    useNativeAnimations?: boolean;
+};
+/**
+ * TouchableOpacity bases on timing animation which has been used in RN's core
+ */
+export default class TouchableOpacity extends Component<TouchableOpacityProps> {
+    static defaultProps: {
+        activeOpacity: number;
+        delayLongPress: number;
+        extraButtonProps: {
+            rippleColor: string;
+            exclusive: boolean;
+        };
+    };
+    getChildStyleOpacityWithDefault: () => number;
+    opacity: Animated.Value;
+    setOpacityTo: (value: number, duration: number) => void;
+    onStateChange: (_from: number, to: number) => void;
+    render(): React.JSX.Element;
+}

package/lib/typescript/components/touchables/TouchableWithoutFeedback.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import GenericTouchable, { GenericTouchableProps } from './GenericTouchable';
+export type TouchableWithoutFeedbackProps = GenericTouchableProps;
+declare const TouchableWithoutFeedback: React.ForwardRefExoticComponent<GenericTouchableProps & {
+    children?: React.ReactNode;
+} & React.RefAttributes<GenericTouchable>>;
+export default TouchableWithoutFeedback;

package/lib/typescript/components/touchables/index.d.ts

@@ -0,0 +1,7 @@
+export type { TouchableHighlightProps } from './TouchableHighlight';
+export type { TouchableOpacityProps } from './TouchableOpacity';
+export type { TouchableWithoutFeedbackProps } from './TouchableWithoutFeedback';
+export { default as TouchableNativeFeedback } from './TouchableNativeFeedback';
+export { default as TouchableWithoutFeedback } from './TouchableWithoutFeedback';
+export { default as TouchableOpacity } from './TouchableOpacity';
+export { default as TouchableHighlight } from './TouchableHighlight';

package/lib/typescript/getReactNativeVersion.d.ts

@@ -0,0 +1,4 @@
+export declare function getReactNativeVersion(): {
+    major: number;
+    minor: number;
+};

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

@@ -0,0 +1 @@
+export declare function getReactNativeVersion(): void;

package/lib/typescript/getShadowNodeFromRef.d.ts

@@ -0,0 +1 @@
+export declare function getShadowNodeFromRef(ref: any): any;

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

@@ -0,0 +1 @@
+export declare function getShadowNodeFromRef(_ref: any): null;

package/lib/typescript/ghQueueMicrotask.d.ts

@@ -0,0 +1 @@
+export declare const ghQueueMicrotask: typeof queueMicrotask;

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

@@ -0,0 +1,34 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare const flingGestureHandlerProps: readonly ["numberOfPointers", "direction"];
+export type FlingGestureHandlerEventPayload = {
+    x: number;
+    y: number;
+    absoluteX: number;
+    absoluteY: number;
+};
+export interface FlingGestureConfig {
+    /**
+     * Expressed allowed direction of movement. It's possible to pass one or many
+     * directions in one parameter:
+     *
+     * ```js
+     * direction={Directions.RIGHT | Directions.LEFT}
+     * ```
+     *
+     * or
+     *
+     * ```js
+     * direction={Directions.DOWN}
+     * ```
+     */
+    direction?: number;
+    /**
+     * Determine exact number of points required to handle the fling gesture.
+     */
+    numberOfPointers?: number;
+}
+export interface FlingGestureHandlerProps extends BaseGestureHandlerProps<FlingGestureHandlerEventPayload>, FlingGestureConfig {
+}
+export declare const flingHandlerName = "FlingGestureHandler";
+export type FlingGestureHandler = typeof FlingGestureHandler;
+export declare const FlingGestureHandler: import("react").ComponentType<FlingGestureHandlerProps & import("react").RefAttributes<any>>;

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

@@ -0,0 +1,44 @@
+import React, { PropsWithChildren } from 'react';
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare const forceTouchGestureHandlerProps: readonly ["minForce", "maxForce", "feedbackOnActivation"];
+declare class ForceTouchFallback extends React.Component<PropsWithChildren<unknown>> {
+    static forceTouchAvailable: boolean;
+    componentDidMount(): void;
+    render(): React.ReactNode;
+}
+export type ForceTouchGestureHandlerEventPayload = {
+    x: number;
+    y: number;
+    absoluteX: number;
+    absoluteY: number;
+    /**
+     * The pressure of a touch.
+     */
+    force: number;
+};
+export interface ForceTouchGestureConfig {
+    /**
+     *
+     * A minimal pressure that is required before handler can activate. Should be a
+     * value from range `[0.0, 1.0]`. Default is `0.2`.
+     */
+    minForce?: number;
+    /**
+     * A maximal pressure that could be applied for handler. If the pressure is
+     * greater, handler fails. Should be a value from range `[0.0, 1.0]`.
+     */
+    maxForce?: number;
+    /**
+     * Boolean value defining if haptic feedback has to be performed on
+     * activation.
+     */
+    feedbackOnActivation?: boolean;
+}
+export interface ForceTouchGestureHandlerProps extends BaseGestureHandlerProps<ForceTouchGestureHandlerEventPayload>, ForceTouchGestureConfig {
+}
+export type ForceTouchGestureHandler = typeof ForceTouchGestureHandler & {
+    forceTouchAvailable: boolean;
+};
+export declare const forceTouchHandlerName = "ForceTouchGestureHandler";
+export declare const ForceTouchGestureHandler: typeof ForceTouchFallback | React.ComponentType<ForceTouchGestureHandlerProps & React.RefAttributes<any>>;
+export {};

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

@@ -0,0 +1,56 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare const longPressGestureHandlerProps: readonly ["minDurationMs", "maxDist"];
+export 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;
+};
+export interface LongPressGestureConfig {
+    /**
+     * Minimum time, expressed in milliseconds, that a finger must remain pressed on
+     * the corresponding view. The default value is 500.
+     */
+    minDurationMs?: number;
+    /**
+     * Maximum distance, expressed in points, that defines how far the finger is
+     * allowed to travel during a long press gesture. If the finger travels
+     * further than the defined distance and the handler hasn't yet activated, it
+     * will fail to recognize the gesture. The default value is 10.
+     */
+    maxDist?: number;
+}
+export interface LongPressGestureHandlerProps extends BaseGestureHandlerProps<LongPressGestureHandlerEventPayload>, LongPressGestureConfig {
+}
+export declare const longPressHandlerName = "LongPressGestureHandler";
+export type LongPressGestureHandler = typeof LongPressGestureHandler;
+export declare const LongPressGestureHandler: import("react").ComponentType<LongPressGestureHandlerProps & import("react").RefAttributes<any>>;

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

@@ -0,0 +1,28 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare const nativeViewGestureHandlerProps: readonly ["shouldActivateOnStart", "disallowInterruption"];
+export interface NativeViewGestureConfig {
+    /**
+     * Android only.
+     *
+     * Determines whether the handler should check for an existing touch event on
+     * instantiation.
+     */
+    shouldActivateOnStart?: boolean;
+    /**
+     * When `true`, cancels all other gesture handlers when this
+     * `NativeViewGestureHandler` receives an `ACTIVE` state event.
+     */
+    disallowInterruption?: boolean;
+}
+export interface NativeViewGestureHandlerProps extends BaseGestureHandlerProps<NativeViewGestureHandlerPayload>, NativeViewGestureConfig {
+}
+export type NativeViewGestureHandlerPayload = {
+    /**
+     * True if gesture was performed inside of containing view, false otherwise.
+     */
+    pointerInside: boolean;
+};
+export declare const nativeViewProps: readonly ["id", "enabled", "shouldCancelWhenOutside", "hitSlop", "cancelsTouchesInView", "userSelect", "activeCursor", "waitFor", "simultaneousHandlers", "blocksHandlers", "onBegan", "onFailed", "onCancelled", "onActivated", "onEnded", "onGestureEvent", "onHandlerStateChange", "shouldActivateOnStart", "disallowInterruption"];
+export declare const nativeViewHandlerName = "NativeViewGestureHandler";
+export type NativeViewGestureHandler = typeof NativeViewGestureHandler;
+export declare const NativeViewGestureHandler: import("react").ComponentType<NativeViewGestureHandlerProps & import("react").RefAttributes<any>>;

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

@@ -0,0 +1,139 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare const panGestureHandlerProps: readonly ["activeOffsetY", "activeOffsetX", "failOffsetY", "failOffsetX", "minDist", "minVelocity", "minVelocityX", "minVelocityY", "minPointers", "maxPointers", "avgTouches", "enableTrackpadTwoFingerGesture", "activateAfterLongPress"];
+export declare const panGestureHandlerCustomNativeProps: readonly ["activeOffsetYStart", "activeOffsetYEnd", "activeOffsetXStart", "activeOffsetXEnd", "failOffsetYStart", "failOffsetYEnd", "failOffsetXStart", "failOffsetXEnd"];
+export 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;
+};
+interface CommonPanProperties {
+    /**
+     * Minimum distance the finger (or multiple finger) need to travel before the
+     * handler activates. Expressed in points.
+     */
+    minDist?: number;
+    /**
+     * Android only.
+     */
+    avgTouches?: boolean;
+    /**
+     * Enables two-finger gestures on supported devices, for example iPads with
+     * trackpads. If not enabled the gesture will require click + drag, with
+     * enableTrackpadTwoFingerGesture swiping with two fingers will also trigger
+     * the gesture.
+     */
+    enableTrackpadTwoFingerGesture?: boolean;
+    /**
+     * A number of fingers that is required to be placed before handler can
+     * activate. Should be a higher or equal to 0 integer.
+     */
+    minPointers?: number;
+    /**
+     * When the given number of fingers is placed on the screen and handler hasn't
+     * yet activated it will fail recognizing the gesture. Should be a higher or
+     * equal to 0 integer.
+     */
+    maxPointers?: number;
+    minVelocity?: number;
+    minVelocityX?: number;
+    minVelocityY?: number;
+    activateAfterLongPress?: number;
+}
+export interface PanGestureConfig extends CommonPanProperties {
+    activeOffsetYStart?: number;
+    activeOffsetYEnd?: number;
+    activeOffsetXStart?: number;
+    activeOffsetXEnd?: number;
+    failOffsetYStart?: number;
+    failOffsetYEnd?: number;
+    failOffsetXStart?: number;
+    failOffsetXEnd?: number;
+}
+export interface PanGestureHandlerProps extends BaseGestureHandlerProps<PanGestureHandlerEventPayload>, CommonPanProperties {
+    /**
+     * Range along X axis (in points) where fingers travels without activation of
+     * handler. Moving outside of this range implies activation of handler. Range
+     * can be given as an array or a single number. If range is set as an array,
+     * first value must be lower or equal to 0, a the second one higher or equal
+     * to 0. If only one number `p` is given a range of `(-inf, p)` will be used
+     * if `p` is higher or equal to 0 and `(-p, inf)` otherwise.
+     */
+    activeOffsetY?: number | number[];
+    /**
+     * Range along X axis (in points) where fingers travels without activation of
+     * handler. Moving outside of this range implies activation of handler. Range
+     * can be given as an array or a single number. If range is set as an array,
+     * first value must be lower or equal to 0, a the second one higher or equal
+     * to 0. If only one number `p` is given a range of `(-inf, p)` will be used
+     * if `p` is higher or equal to 0 and `(-p, inf)` otherwise.
+     */
+    activeOffsetX?: number | number[];
+    /**
+     * When the finger moves outside this range (in points) along Y axis and
+     * handler hasn't yet activated it will fail recognizing the gesture. Range
+     * can be given as an array or a single number. If range is set as an array,
+     * first value must be lower or equal to 0, a the second one higher or equal
+     * to 0. If only one number `p` is given a range of `(-inf, p)` will be used
+     * if `p` is higher or equal to 0 and `(-p, inf)` otherwise.
+     */
+    failOffsetY?: number | number[];
+    /**
+     * When the finger moves outside this range (in points) along X axis and
+     * handler hasn't yet activated it will fail recognizing the gesture. Range
+     * can be given as an array or a single number. If range is set as an array,
+     * first value must be lower or equal to 0, a the second one higher or equal
+     * to 0. If only one number `p` is given a range of `(-inf, p)` will be used
+     * if `p` is higher or equal to 0 and `(-p, inf)` otherwise.
+     */
+    failOffsetX?: number | number[];
+}
+export declare const panHandlerName = "PanGestureHandler";
+export type PanGestureHandler = typeof PanGestureHandler;
+export declare const PanGestureHandler: import("react").ComponentType<PanGestureHandlerProps & import("react").RefAttributes<any>>;
+export declare function managePanProps(props: PanGestureHandlerProps): PanGestureHandlerProps & Partial<Record<"activeOffsetXStart" | "activeOffsetXEnd" | "failOffsetXStart" | "failOffsetXEnd" | "activeOffsetYStart" | "activeOffsetYEnd" | "failOffsetYStart" | "failOffsetYEnd", number>>;
+export {};

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

@@ -0,0 +1,29 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export type PinchGestureHandlerEventPayload = {
+    /**
+     * The scale factor relative to the points of the two touches in screen
+     * coordinates.
+     */
+    scale: number;
+    /**
+     * Position expressed in points along X axis of center anchor point of
+     * gesture.
+     */
+    focalX: number;
+    /**
+     * Position expressed in points along Y axis of center anchor point of
+     * gesture.
+     */
+    focalY: number;
+    /**
+     *
+     * Velocity of the pan gesture the current moment. The value is expressed in
+     * point units per second.
+     */
+    velocity: number;
+};
+export interface PinchGestureHandlerProps extends BaseGestureHandlerProps<PinchGestureHandlerEventPayload> {
+}
+export declare const pinchHandlerName = "PinchGestureHandler";
+export type PinchGestureHandler = typeof PinchGestureHandler;
+export declare const PinchGestureHandler: import("react").ComponentType<PinchGestureHandlerProps & import("react").RefAttributes<any>>;

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

@@ -0,0 +1 @@
+export { PressabilityDebugView } from 'react-native/Libraries/Pressability/PressabilityDebug';

package/lib/typescript/handlers/PressabilityDebugView.web.d.ts

@@ -0,0 +1 @@
+export declare function PressabilityDebugView(): null;

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

@@ -0,0 +1,29 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export type RotationGestureHandlerEventPayload = {
+    /**
+     * Amount rotated, expressed in radians, from the gesture's focal point
+     * (anchor).
+     */
+    rotation: number;
+    /**
+     * X coordinate, expressed in points, of the gesture's central focal point
+     * (anchor).
+     */
+    anchorX: number;
+    /**
+     * Y coordinate, expressed in points, of the gesture's central focal point
+     * (anchor).
+     */
+    anchorY: number;
+    /**
+     *
+     * Instantaneous velocity, expressed in point units per second, of the
+     * gesture.
+     */
+    velocity: number;
+};
+export interface RotationGestureHandlerProps extends BaseGestureHandlerProps<RotationGestureHandlerEventPayload> {
+}
+export declare const rotationHandlerName = "RotationGestureHandler";
+export type RotationGestureHandler = typeof RotationGestureHandler;
+export declare const RotationGestureHandler: import("react").ComponentType<RotationGestureHandlerProps & import("react").RefAttributes<any>>;

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

@@ -0,0 +1,57 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare const tapGestureHandlerProps: readonly ["maxDurationMs", "maxDelayMs", "numberOfTaps", "maxDeltaX", "maxDeltaY", "maxDist", "minPointers"];
+export type TapGestureHandlerEventPayload = {
+    x: number;
+    y: number;
+    absoluteX: number;
+    absoluteY: number;
+};
+export interface TapGestureConfig {
+    /**
+     * Minimum number of pointers (fingers) required to be placed before the
+     * handler activates. Should be a positive integer.
+     * The default value is 1.
+     */
+    minPointers?: number;
+    /**
+     * Maximum time, expressed in milliseconds, that defines how fast a finger
+     * must be released after a touch. The default value is 500.
+     */
+    maxDurationMs?: number;
+    /**
+     * Maximum time, expressed in milliseconds, that can pass before the next tap
+     * if many taps are required. The default value is 500.
+     */
+    maxDelayMs?: number;
+    /**
+     * Number of tap gestures required to activate the handler. The default value
+     * is 1.
+     */
+    numberOfTaps?: number;
+    /**
+     * Maximum distance, expressed in points, that defines how far the finger is
+     * allowed to travel along the X axis during a tap gesture. If the finger
+     * travels further than the defined distance along the X axis and the handler
+     * hasn't yet activated, it will fail to recognize the gesture.
+     */
+    maxDeltaX?: number;
+    /**
+     * Maximum distance, expressed in points, that defines how far the finger is
+     * allowed to travel along the Y axis during a tap gesture. If the finger
+     * travels further than the defined distance along the Y axis and the handler
+     * hasn't yet activated, it will fail to recognize the gesture.
+     */
+    maxDeltaY?: number;
+    /**
+     * Maximum distance, expressed in points, that defines how far the finger is
+     * allowed to travel during a tap gesture. If the finger travels further than
+     * the defined distance and the handler hasn't yet
+     * activated, it will fail to recognize the gesture.
+     */
+    maxDist?: number;
+}
+export interface TapGestureHandlerProps extends BaseGestureHandlerProps<TapGestureHandlerEventPayload>, TapGestureConfig {
+}
+export declare const tapHandlerName = "TapGestureHandler";
+export type TapGestureHandler = typeof TapGestureHandler;
+export declare const TapGestureHandler: import("react").ComponentType<TapGestureHandlerProps & import("react").RefAttributes<any>>;

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

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+type CreateHandlerArgs<HandlerPropsT extends Record<string, unknown>> = Readonly<{
+    name: string;
+    allowedProps: Readonly<Extract<keyof HandlerPropsT, string>[]>;
+    config: Readonly<Record<string, unknown>>;
+    transformProps?: (props: HandlerPropsT) => HandlerPropsT;
+    customNativeProps?: Readonly<string[]>;
+}>;
+export default function createHandler<T extends BaseGestureHandlerProps<U>, U extends Record<string, unknown>>({ name, allowedProps, config, transformProps, customNativeProps, }: CreateHandlerArgs<T>): React.ComponentType<T & React.RefAttributes<any>>;
+export {};

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

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import { NativeViewGestureHandlerProps } from './NativeViewGestureHandler';
+export default function createNativeWrapper<P>(Component: React.ComponentType<P>, config?: Readonly<NativeViewGestureHandlerProps>): React.ForwardRefExoticComponent<React.PropsWithoutRef<P & NativeViewGestureHandlerProps> & React.RefAttributes<React.ComponentType<any>>>;

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

@@ -0,0 +1,68 @@
+import * as React from 'react';
+import { State } from '../State';
+import { TouchEventType } from '../TouchEventType';
+import { ValueOf } from '../typeUtils';
+export declare const baseGestureHandlerProps: readonly ["id", "enabled", "shouldCancelWhenOutside", "hitSlop", "cancelsTouchesInView", "userSelect", "activeCursor", "waitFor", "simultaneousHandlers", "blocksHandlers", "onBegan", "onFailed", "onCancelled", "onActivated", "onEnded", "onGestureEvent", "onHandlerStateChange"];
+export declare const baseGestureHandlerWithMonitorProps: string[];
+export interface GestureEventPayload {
+    handlerTag: number;
+    numberOfPointers: number;
+    state: ValueOf<typeof State>;
+}
+export interface HandlerStateChangeEventPayload extends GestureEventPayload {
+    oldState: ValueOf<typeof State>;
+}
+export type HitSlop = number | Partial<Record<'left' | 'right' | 'top' | 'bottom' | 'vertical' | 'horizontal', number>> | Record<'width' | 'left', number> | Record<'width' | 'right', number> | Record<'height' | 'top', number> | Record<'height' | 'bottom', number>;
+export type UserSelect = 'none' | 'auto' | 'text';
+export type ActiveCursor = 'auto' | 'default' | 'none' | 'context-menu' | 'help' | 'pointer' | 'progress' | 'wait' | 'cell' | 'crosshair' | 'text' | 'vertical-text' | 'alias' | 'copy' | 'move' | 'no-drop' | 'not-allowed' | 'grab' | 'grabbing' | 'e-resize' | 'n-resize' | 'ne-resize' | 'nw-resize' | 's-resize' | 'se-resize' | 'sw-resize' | 'w-resize' | 'ew-resize' | 'ns-resize' | 'nesw-resize' | 'nwse-resize' | 'col-resize' | 'row-resize' | 'all-scroll' | 'zoom-in' | 'zoom-out';
+export interface GestureEvent<ExtraEventPayloadT = Record<string, unknown>> {
+    nativeEvent: Readonly<GestureEventPayload & ExtraEventPayloadT>;
+}
+export interface HandlerStateChangeEvent<ExtraEventPayloadT = Record<string, unknown>> {
+    nativeEvent: Readonly<HandlerStateChangeEventPayload & ExtraEventPayloadT>;
+}
+export type TouchData = {
+    id: number;
+    x: number;
+    y: number;
+    absoluteX: number;
+    absoluteY: number;
+};
+export type GestureTouchEvent = {
+    handlerTag: number;
+    numberOfTouches: number;
+    state: ValueOf<typeof State>;
+    eventType: TouchEventType;
+    allTouches: TouchData[];
+    changedTouches: TouchData[];
+};
+export type GestureUpdateEvent<GestureEventPayloadT = Record<string, unknown>> = GestureEventPayload & GestureEventPayloadT;
+export type GestureStateChangeEvent<GestureStateChangeEventPayloadT = Record<string, unknown>> = HandlerStateChangeEventPayload & GestureStateChangeEventPayloadT;
+export type CommonGestureConfig = {
+    enabled?: boolean;
+    shouldCancelWhenOutside?: boolean;
+    hitSlop?: HitSlop;
+    userSelect?: UserSelect;
+    activeCursor?: ActiveCursor;
+};
+export type BaseGestureHandlerProps<ExtraEventPayloadT extends Record<string, unknown> = Record<string, unknown>> = CommonGestureConfig & {
+    id?: string;
+    waitFor?: React.Ref<unknown> | React.Ref<unknown>[];
+    simultaneousHandlers?: React.Ref<unknown> | React.Ref<unknown>[];
+    blocksHandlers?: React.Ref<unknown> | React.Ref<unknown>[];
+    testID?: string;
+    cancelsTouchesInView?: boolean;
+    onBegan?: (event: HandlerStateChangeEvent) => void;
+    onFailed?: (event: HandlerStateChangeEvent) => void;
+    onCancelled?: (event: HandlerStateChangeEvent) => void;
+    onActivated?: (event: HandlerStateChangeEvent) => void;
+    onEnded?: (event: HandlerStateChangeEvent) => void;
+    onGestureEvent?: (event: GestureEvent<ExtraEventPayloadT>) => void;
+    onHandlerStateChange?: (event: HandlerStateChangeEvent<ExtraEventPayloadT>) => void;
+    children?: React.ReactNode;
+};
+export declare function filterConfig(props: Record<string, unknown>, validProps: string[], defaults?: Record<string, unknown>): {
+    [x: string]: unknown;
+};
+export declare function findNodeHandle(node: null | number | React.Component<any, any> | React.ComponentClass<any>): null | number | React.Component<any, any> | React.ComponentClass<any>;
+export declare function scheduleFlushOperations(): void;

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

@@ -0,0 +1,42 @@
+import { BaseButtonProps, BorderlessButtonProps, RawButtonProps, RectButtonProps } from '../components/GestureButtons';
+import { GestureEvent, GestureEventPayload, HandlerStateChangeEvent, HandlerStateChangeEventPayload } from './gestureHandlerCommon';
+import { FlingGestureHandlerEventPayload, FlingGestureHandlerProps } from './FlingGestureHandler';
+import { ForceTouchGestureHandlerEventPayload, ForceTouchGestureHandlerProps } from './ForceTouchGestureHandler';
+import { LongPressGestureHandlerEventPayload, LongPressGestureHandlerProps } from './LongPressGestureHandler';
+import { PanGestureHandlerEventPayload, PanGestureHandlerProps } from './PanGestureHandler';
+import { PinchGestureHandlerEventPayload, PinchGestureHandlerProps } from './PinchGestureHandler';
+import { RotationGestureHandlerEventPayload, RotationGestureHandlerProps } from './RotationGestureHandler';
+import { TapGestureHandlerEventPayload, TapGestureHandlerProps } from './TapGestureHandler';
+import { NativeViewGestureHandlerPayload, NativeViewGestureHandlerProps } from './NativeViewGestureHandler';
+export type GestureHandlerGestureEventNativeEvent = GestureEventPayload;
+export type GestureHandlerStateChangeNativeEvent = HandlerStateChangeEventPayload;
+export type GestureHandlerGestureEvent = GestureEvent;
+export type GestureHandlerStateChangeEvent = HandlerStateChangeEvent;
+export type NativeViewGestureHandlerGestureEvent = GestureEvent<NativeViewGestureHandlerPayload>;
+export type NativeViewGestureHandlerStateChangeEvent = HandlerStateChangeEvent<NativeViewGestureHandlerPayload>;
+export type TapGestureHandlerGestureEvent = GestureEvent<TapGestureHandlerEventPayload>;
+export type TapGestureHandlerStateChangeEvent = HandlerStateChangeEvent<TapGestureHandlerEventPayload>;
+export type ForceTouchGestureHandlerGestureEvent = GestureEvent<ForceTouchGestureHandlerEventPayload>;
+export type ForceTouchGestureHandlerStateChangeEvent = HandlerStateChangeEvent<ForceTouchGestureHandlerEventPayload>;
+export type LongPressGestureHandlerGestureEvent = GestureEvent<LongPressGestureHandlerEventPayload>;
+export type LongPressGestureHandlerStateChangeEvent = HandlerStateChangeEvent<LongPressGestureHandlerEventPayload>;
+export type PanGestureHandlerGestureEvent = GestureEvent<PanGestureHandlerEventPayload>;
+export type PanGestureHandlerStateChangeEvent = HandlerStateChangeEvent<PanGestureHandlerEventPayload>;
+export type PinchGestureHandlerGestureEvent = GestureEvent<PinchGestureHandlerEventPayload>;
+export type PinchGestureHandlerStateChangeEvent = HandlerStateChangeEvent<PinchGestureHandlerEventPayload>;
+export type RotationGestureHandlerGestureEvent = GestureEvent<RotationGestureHandlerEventPayload>;
+export type RotationGestureHandlerStateChangeEvent = HandlerStateChangeEvent<RotationGestureHandlerEventPayload>;
+export type FlingGestureHandlerGestureEvent = GestureEvent<FlingGestureHandlerEventPayload>;
+export type FlingGestureHandlerStateChangeEvent = HandlerStateChangeEvent<FlingGestureHandlerEventPayload>;
+export type NativeViewGestureHandlerProperties = NativeViewGestureHandlerProps;
+export type TapGestureHandlerProperties = TapGestureHandlerProps;
+export type LongPressGestureHandlerProperties = LongPressGestureHandlerProps;
+export type PanGestureHandlerProperties = PanGestureHandlerProps;
+export type PinchGestureHandlerProperties = PinchGestureHandlerProps;
+export type RotationGestureHandlerProperties = RotationGestureHandlerProps;
+export type FlingGestureHandlerProperties = FlingGestureHandlerProps;
+export type ForceTouchGestureHandlerProperties = ForceTouchGestureHandlerProps;
+export type RawButtonProperties = RawButtonProps;
+export type BaseButtonProperties = BaseButtonProps;
+export type RectButtonProperties = RectButtonProps;
+export type BorderlessButtonProperties = BorderlessButtonProps;

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

@@ -0,0 +1,19 @@
+import React from 'react';
+import { GestureType, HandlerCallbacks } from './gesture';
+import { SharedValue } from './reanimatedWrapper';
+import { UserSelect } from '../gestureHandlerCommon';
+import { ComposedGesture } from './gestureComposition';
+export type GestureConfigReference = {
+    config: GestureType[];
+    animatedEventHandler: unknown;
+    animatedHandlers: SharedValue<HandlerCallbacks<Record<string, unknown>>[] | null> | null;
+    firstExecution: boolean;
+    useReanimatedHook: boolean;
+};
+interface GestureDetectorProps {
+    gesture: ComposedGesture | GestureType;
+    userSelect?: UserSelect;
+    children?: React.ReactNode;
+}
+export declare const GestureDetector: (props: GestureDetectorProps) => React.JSX.Element;
+export {};

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

@@ -0,0 +1,4 @@
+import { GestureTouchEvent, GestureUpdateEvent, GestureStateChangeEvent } from '../gestureHandlerCommon';
+export declare function onGestureHandlerEvent(event: GestureUpdateEvent | GestureStateChangeEvent | GestureTouchEvent): void;
+export declare function startListening(): void;
+export declare function stopListening(): void;