react-native-gesture-handler 2.17.1 → 2.18.0

package/lib/typescript/components/ReanimatedSwipeable.d.ts

@@ -0,0 +1,125 @@
+import React, { ForwardedRef } from 'react';
+import type { PanGestureHandlerProps } from '../handlers/PanGestureHandler';
+import { SharedValue } from 'react-native-reanimated';
+import { StyleProp, ViewStyle } from 'react-native';
+type SwipeableExcludes = Exclude<keyof PanGestureHandlerProps, 'onGestureEvent' | 'onHandlerStateChange'>;
+export interface SwipeableProps extends Pick<PanGestureHandlerProps, SwipeableExcludes> {
+    /**
+     * 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;
+    /**
+     * Specifies how much the visual interaction will be delayed compared to the
+     * gesture distance. e.g. value of 1 will indicate that the swipeable panel
+     * should exactly follow the gesture, 2 means it is going to be two times
+     * "slower".
+     */
+    friction?: number;
+    /**
+     * Distance from the left edge at which released panel will animate to the
+     * open state (or the open panel will animate into the closed state). By
+     * default it's a half of the panel's width.
+     */
+    leftThreshold?: number;
+    /**
+     * Distance from the right edge at which released panel will animate to the
+     * open state (or the open panel will animate into the closed state). By
+     * default it's a half of the panel's width.
+     */
+    rightThreshold?: number;
+    /**
+     * Distance that the panel must be dragged from the left edge to be considered
+     * a swipe. The default value is 10.
+     */
+    dragOffsetFromLeftEdge?: number;
+    /**
+     * Distance that the panel must be dragged from the right edge to be considered
+     * a swipe. The default value is 10.
+     */
+    dragOffsetFromRightEdge?: number;
+    /**
+     * Value indicating if the swipeable panel can be pulled further than the left
+     * actions panel's width. It is set to true by default as long as the left
+     * panel render method is present.
+     */
+    overshootLeft?: boolean;
+    /**
+     * Value indicating if the swipeable panel can be pulled further than the
+     * right actions panel's width. It is set to true by default as long as the
+     * right panel render method is present.
+     */
+    overshootRight?: boolean;
+    /**
+     * Specifies how much the visual interaction will be delayed compared to the
+     * gesture distance at overshoot. Default value is 1, it mean no friction, for
+     * a native feel, try 8 or above.
+     */
+    overshootFriction?: number;
+    /**
+     * Called when action panel gets open (either right or left).
+     */
+    onSwipeableOpen?: (direction: 'left' | 'right', swipeable: SwipeableMethods) => void;
+    /**
+     * Called when action panel is closed.
+     */
+    onSwipeableClose?: (direction: 'left' | 'right', swipeable: SwipeableMethods) => void;
+    /**
+     * Called when action panel starts animating on open (either right or left).
+     */
+    onSwipeableWillOpen?: (direction: 'left' | 'right') => void;
+    /**
+     * Called when action panel starts animating on close.
+     */
+    onSwipeableWillClose?: (direction: 'left' | 'right') => void;
+    /**
+     * Called when action panel starts being shown on dragging to open.
+     */
+    onSwipeableOpenStartDrag?: (direction: 'left' | 'right') => void;
+    /**
+     * Called when action panel starts being shown on dragging to close.
+     */
+    onSwipeableCloseStartDrag?: (direction: 'left' | 'right') => void;
+    /**
+     *
+     * This map describes the values to use as inputRange for extra interpolation:
+     * AnimatedValue: [startValue, endValue]
+     *
+     * progressAnimatedValue: [0, 1] dragAnimatedValue: [0, +]
+     *
+     * To support `rtl` flexbox layouts use `flexDirection` styling.
+     * */
+    renderLeftActions?: (progressAnimatedValue: SharedValue<number>, dragAnimatedValue: SharedValue<number>, swipeable: SwipeableMethods) => React.ReactNode;
+    /**
+     *
+     * This map describes the values to use as inputRange for extra interpolation:
+     * AnimatedValue: [startValue, endValue]
+     *
+     * progressAnimatedValue: [0, 1] dragAnimatedValue: [0, -]
+     *
+     * To support `rtl` flexbox layouts use `flexDirection` styling.
+     * */
+    renderRightActions?: (progressAnimatedValue: SharedValue<number>, dragAnimatedValue: SharedValue<number>, swipeable: SwipeableMethods) => React.ReactNode;
+    animationOptions?: Record<string, unknown>;
+    /**
+     * Style object for the container (`Animated.View`), for example to override
+     * `overflow: 'hidden'`.
+     */
+    containerStyle?: StyleProp<ViewStyle>;
+    /**
+     * Style object for the children container (`Animated.View`), for example to
+     * apply `flex: 1`
+     */
+    childrenContainerStyle?: StyleProp<ViewStyle>;
+}
+export interface SwipeableMethods {
+    close: () => void;
+    openLeft: () => void;
+    openRight: () => void;
+    reset: () => void;
+}
+declare const Swipeable: React.ForwardRefExoticComponent<SwipeableProps & React.RefAttributes<SwipeableMethods>>;
+export default Swipeable;
+export type SwipeableRef = ForwardedRef<SwipeableMethods>;

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

@@ -1,9 +1,9 @@
 import * as React from 'react';
 import { Component } from 'react';
-import { StyleProp, ViewStyle, TouchableWithoutFeedbackProps, Insets } from 'react-native';
-import { GestureEvent, HandlerStateChangeEvent, UserSelect } from '../../handlers/gestureHandlerCommon';
-import { NativeViewGestureHandlerPayload } from '../../handlers/NativeViewGestureHandler';
-import { TouchableNativeFeedbackExtraProps } from './TouchableNativeFeedback.android';
+import { GestureEvent, HandlerStateChangeEvent } from '../../handlers/gestureHandlerCommon';
+import type { NativeViewGestureHandlerPayload } from '../../handlers/GestureHandlerEventPayload';
+import type { TouchableNativeFeedbackExtraProps } from './TouchableNativeFeedbackProps';
+import type { GenericTouchableProps } from './GenericTouchableProps';
 /**
  * Each touchable is a states' machine which preforms transitions.
  * On very beginning (and on the very end or recognition) touchable is
@@ -17,18 +17,6 @@ export declare const TOUCHABLE_STATE: {
     readonly MOVED_OUTSIDE: 2;
 };
 type TouchableState = typeof TOUCHABLE_STATE[keyof typeof TOUCHABLE_STATE];
-export interface GenericTouchableProps extends Omit<TouchableWithoutFeedbackProps, 'hitSlop'> {
-    onPress?: () => void;
-    onPressIn?: () => void;
-    onPressOut?: () => void;
-    onLongPress?: () => void;
-    nativeID?: string;
-    shouldActivateOnStart?: boolean;
-    disallowInterruption?: boolean;
-    containerStyle?: StyleProp<ViewStyle>;
-    hitSlop?: Insets | number;
-    userSelect?: UserSelect;
-}
 interface InternalProps {
     extraButtonProps: TouchableNativeFeedbackExtraProps;
     onStateChange?: (oldState: TouchableState, newState: TouchableState) => void;

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

@@ -0,0 +1,14 @@
+import type { StyleProp, ViewStyle, TouchableWithoutFeedbackProps, Insets } from 'react-native';
+import type { UserSelect } from '../../handlers/gestureHandlerCommon';
+export interface GenericTouchableProps extends Omit<TouchableWithoutFeedbackProps, 'hitSlop'> {
+    onPress?: () => void;
+    onPressIn?: () => void;
+    onPressOut?: () => void;
+    onLongPress?: () => void;
+    nativeID?: string;
+    shouldActivateOnStart?: boolean;
+    disallowInterruption?: boolean;
+    containerStyle?: StyleProp<ViewStyle>;
+    hitSlop?: Insets | number;
+    userSelect?: UserSelect;
+}

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

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { Component } from 'react';
-import { GenericTouchableProps } from './GenericTouchable';
+import type { GenericTouchableProps } from './GenericTouchableProps';
 import { TouchableHighlightProps as RNTouchableHighlightProps, ColorValue } from 'react-native';
 interface State {
     extraChildStyle: null | {

package/lib/typescript/components/touchables/TouchableNativeFeedback.android.d.ts

@@ -1,14 +1,7 @@
-import { TouchableNativeFeedbackProps as RNTouchableNativeFeedbackProps, ColorValue } from 'react-native';
+import { ColorValue } from 'react-native';
 import * as React from 'react';
 import { Component } from 'react';
-import { GenericTouchableProps } from './GenericTouchable';
-export type TouchableNativeFeedbackExtraProps = {
-    borderless?: boolean;
-    rippleColor?: number | null;
-    rippleRadius?: number | null;
-    foreground?: boolean;
-};
-export type TouchableNativeFeedbackProps = RNTouchableNativeFeedbackProps & GenericTouchableProps;
+import { TouchableNativeFeedbackProps, TouchableNativeFeedbackExtraProps } from './TouchableNativeFeedbackProps';
 /**
  * TouchableNativeFeedback behaves slightly different than RN's TouchableNativeFeedback.
  * There's small difference with handling long press ripple since RN's implementation calls

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

@@ -0,0 +1,9 @@
+import type { TouchableNativeFeedbackProps as RNTouchableNativeFeedbackProps } from 'react-native';
+import type { GenericTouchableProps } from './GenericTouchableProps';
+export type TouchableNativeFeedbackExtraProps = {
+    borderless?: boolean;
+    rippleColor?: number | null;
+    rippleRadius?: number | null;
+    foreground?: boolean;
+};
+export type TouchableNativeFeedbackProps = RNTouchableNativeFeedbackProps & GenericTouchableProps;

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

@@ -1,5 +1,5 @@
 import { Animated, TouchableOpacityProps as RNTouchableOpacityProps } from 'react-native';
-import { GenericTouchableProps } from './GenericTouchable';
+import type { GenericTouchableProps } from './GenericTouchableProps';
 import * as React from 'react';
 import { Component } from 'react';
 export type TouchableOpacityProps = RNTouchableOpacityProps & GenericTouchableProps & {

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

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

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

@@ -1,11 +1,7 @@
+/// <reference types="react" />
+import type { FlingGestureHandlerEventPayload } from './GestureHandlerEventPayload';
 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

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

@@ -1,21 +1,12 @@
 import React, { PropsWithChildren } from 'react';
 import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+import type { ForceTouchGestureHandlerEventPayload } from './GestureHandlerEventPayload';
 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 {
     /**
      *

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

@@ -0,0 +1,159 @@
+export type FlingGestureHandlerEventPayload = {
+    x: number;
+    y: number;
+    absoluteX: number;
+    absoluteY: number;
+};
+export type ForceTouchGestureHandlerEventPayload = {
+    x: number;
+    y: number;
+    absoluteX: number;
+    absoluteY: number;
+    /**
+     * The pressure of a touch.
+     */
+    force: number;
+};
+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 type NativeViewGestureHandlerPayload = {
+    /**
+     * True if gesture was performed inside of containing view, false otherwise.
+     */
+    pointerInside: boolean;
+};
+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;
+};
+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 type TapGestureHandlerEventPayload = {
+    x: number;
+    y: number;
+    absoluteX: number;
+    absoluteY: number;
+};
+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;
+};

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

@@ -1,40 +1,7 @@
+/// <reference types="react" />
+import { LongPressGestureHandlerEventPayload } from './GestureHandlerEventPayload';
 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

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

@@ -1,3 +1,5 @@
+/// <reference types="react" />
+import type { NativeViewGestureHandlerPayload } from './GestureHandlerEventPayload';
 import { BaseGestureHandlerProps } from './gestureHandlerCommon';
 export declare const nativeViewGestureHandlerProps: readonly ["shouldActivateOnStart", "disallowInterruption"];
 export interface NativeViewGestureConfig {
@@ -16,12 +18,6 @@ export interface NativeViewGestureConfig {
 }
 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", "mouseButton", "enableContextMenu", "touchAction", "waitFor", "simultaneousHandlers", "blocksHandlers", "onBegan", "onFailed", "onCancelled", "onActivated", "onEnded", "onGestureEvent", "onHandlerStateChange", "shouldActivateOnStart", "disallowInterruption"];
 export declare const nativeViewHandlerName = "NativeViewGestureHandler";
 export type NativeViewGestureHandler = typeof NativeViewGestureHandler;

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

@@ -1,56 +1,8 @@
+/// <reference types="react" />
+import type { PanGestureHandlerEventPayload } from './GestureHandlerEventPayload';
 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
@@ -135,5 +87,5 @@ export interface PanGestureHandlerProps extends BaseGestureHandlerProps<PanGestu
 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<"activeOffsetYStart" | "activeOffsetYEnd" | "activeOffsetXStart" | "activeOffsetXEnd" | "failOffsetYStart" | "failOffsetYEnd" | "failOffsetXStart" | "failOffsetXEnd", number>>;
+export declare function managePanProps(props: PanGestureHandlerProps): PanGestureHandlerProps & Partial<Record<"failOffsetXStart" | "failOffsetYStart" | "failOffsetXEnd" | "failOffsetYEnd" | "activeOffsetXStart" | "activeOffsetXEnd" | "activeOffsetYStart" | "activeOffsetYEnd", number>>;
 export {};

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

@@ -1,27 +1,6 @@
+/// <reference types="react" />
+import { PinchGestureHandlerEventPayload } from './GestureHandlerEventPayload';
 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";

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

@@ -1,27 +1,6 @@
+/// <reference types="react" />
+import { RotationGestureHandlerEventPayload } from './GestureHandlerEventPayload';
 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";

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

@@ -1,11 +1,7 @@
+/// <reference types="react" />
+import type { TapGestureHandlerEventPayload } from './GestureHandlerEventPayload';
 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

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

@@ -76,8 +76,3 @@ export type BaseGestureHandlerProps<ExtraEventPayloadT extends Record<string, un
     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;