react-native-gesture-handler 1.10.3 → 2.0.0

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

@@ -1,31 +1,80 @@
 import * as React from 'react';
 import { Component } from 'react';
 import { Animated, StatusBarAnimation, StyleProp, ViewStyle } from 'react-native';
-import { PanGestureHandler } from '../handlers/gestureHandlers';
+import { PanGestureHandler } from '../handlers/PanGestureHandler';
 export declare type DrawerPosition = 'left' | 'right';
 export declare type DrawerState = 'Idle' | 'Dragging' | 'Settling';
 export declare type DrawerType = 'front' | 'back' | 'slide';
 export declare type DrawerLockMode = 'unlocked' | 'locked-closed' | 'locked-open';
 export declare type DrawerKeyboardDismissMode = 'none' | 'on-drag';
 export interface DrawerLayoutProps {
+    /**
+     * This attribute is present in the standard implementation already and is one
+     * of the required params. Gesture handler version of DrawerLayout make it
+     * possible for the function passed as `renderNavigationView` to take an
+     * Animated value as a parameter that indicates the progress of drawer
+     * opening/closing animation (progress value is 0 when closed and 1 when
+     * opened). This can be used by the drawer component to animated its children
+     * while the drawer is opening or closing.
+     */
     renderNavigationView: (progressAnimatedValue: Animated.Value) => React.ReactNode;
     drawerPosition?: DrawerPosition;
     drawerWidth?: number;
     drawerBackgroundColor?: string;
     drawerLockMode?: DrawerLockMode;
     keyboardDismissMode?: DrawerKeyboardDismissMode;
+    /**
+     * Called when the drawer is closed.
+     */
     onDrawerClose?: () => void;
+    /**
+     * Called when the drawer is opened.
+     */
     onDrawerOpen?: () => void;
+    /**
+     * Called when the status of the drawer changes.
+     */
     onDrawerStateChanged?: (newState: DrawerState, drawerWillShow: boolean) => void;
     useNativeAnimations?: boolean;
     drawerType?: DrawerType;
+    /**
+     * Defines how far from the edge of the content view the gesture should
+     * activate.
+     */
     edgeWidth?: number;
     minSwipeDistance?: number;
+    /**
+     * When set to true Drawer component will use
+     * {@link https://reactnative.dev/docs/statusbar StatusBar} API to hide the OS
+     * status bar whenever the drawer is pulled or when its in an "open" state.
+     */
     hideStatusBar?: boolean;
+    /**
+     * @default 'slide'
+     *
+     * Can be used when hideStatusBar is set to true and will select the animation
+     * used for hiding/showing the status bar. See
+     * {@link https://reactnative.dev/docs/statusbar StatusBar} documentation for
+     * more details
+     */
     statusBarAnimation?: StatusBarAnimation;
+    /**
+     * @default black
+     *
+     * Color of a semi-transparent overlay to be displayed on top of the content
+     * view when drawer gets open. A solid color should be used as the opacity is
+     * added by the Drawer itself and the opacity of the overlay is animated (from
+     * 0% to 70%).
+     */
     overlayColor?: string;
     contentContainerStyle?: StyleProp<ViewStyle>;
     drawerContainerStyle?: StyleProp<ViewStyle>;
+    /**
+     * 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;
     onDrawerSlide?: (position: number) => void;
     onGestureRef?: (ref: PanGestureHandler) => void;

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

@@ -2,21 +2,57 @@ import * as React from 'react';
 import { StyleProp, ViewStyle } from 'react-native';
 import { NativeViewGestureHandlerProps } from '../handlers/NativeViewGestureHandler';
 export interface RawButtonProps extends NativeViewGestureHandlerProps {
+    /**
+     * Defines if more than one button could be pressed simultaneously. By default
+     * set true.
+     */
     exclusive?: boolean;
+    /**
+     * Android only.
+     *
+     * Defines color of native ripple animation used since API level 21.
+     */
     rippleColor?: any;
 }
 export interface BaseButtonProps extends RawButtonProps {
+    /**
+     * Called when the button gets pressed (analogous to `onPress` in
+     * `TouchableHighlight` from RN core).
+     */
     onPress?: (pointerInside: boolean) => void;
+    /**
+     * Called when button changes from inactive to active and vice versa. It
+     * passes active state as a boolean variable as a first parameter for that
+     * method.
+     */
     onActiveStateChange?: (active: boolean) => void;
     style?: StyleProp<ViewStyle>;
     testID?: string;
 }
 export interface RectButtonProps extends BaseButtonProps {
+    /**
+     * Background color that will be dimmed when button is in active state.
+     */
     underlayColor?: string;
+    /**
+     * iOS only.
+     *
+     * Opacity applied to the underlay when button is in active state.
+     */
     activeOpacity?: number;
 }
 export interface BorderlessButtonProps extends BaseButtonProps {
+    /**
+     * Android only.
+     *
+     * Set this to false if you want the ripple animation to render only within view bounds.
+     */
     borderless?: boolean;
+    /**
+     * iOS only.
+     *
+     * Opacity applied to the button when it is in an active state.
+     */
     activeOpacity?: number;
 }
 export declare const RawButton: React.ForwardRefExoticComponent<RawButtonProps & NativeViewGestureHandlerProps & React.RefAttributes<React.ComponentType<any>>>;

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

@@ -1,45 +1,18 @@
 import * as React from 'react';
-import { ScrollViewProps as RNScrollViewProps, SwitchProps as RNSwitchProps, TextInputProps as RNTextInputProps, DrawerLayoutAndroidProps as RNDrawerLayoutAndroidProps, FlatList as RNFlatList, FlatListProps as RNFlatListProps } from 'react-native';
+import { PropsWithChildren, ForwardedRef, RefAttributes, ReactElement } from 'react';
+import { ScrollView as RNScrollView, ScrollViewProps as RNScrollViewProps, Switch as RNSwitch, SwitchProps as RNSwitchProps, TextInput as RNTextInput, TextInputProps as RNTextInputProps, DrawerLayoutAndroid as RNDrawerLayoutAndroid, DrawerLayoutAndroidProps as RNDrawerLayoutAndroidProps, FlatList as RNFlatList, FlatListProps as RNFlatListProps } from 'react-native';
 import { NativeViewGestureHandlerProps } from '../handlers/NativeViewGestureHandler';
 export declare const ScrollView: React.ForwardRefExoticComponent<RNScrollViewProps & {
     children?: React.ReactNode;
 } & NativeViewGestureHandlerProps & React.RefAttributes<React.ComponentType<any>>>;
-export declare type ScrollView = typeof ScrollView & {
-    scrollTo(y?: number | {
-        x?: number;
-        y?: number;
-        animated?: boolean;
-    }, x?: number, animated?: boolean): void;
-    scrollToEnd(options?: {
-        animated: boolean;
-    }): void;
-};
+export declare type ScrollView = typeof ScrollView & RNScrollView;
 export declare const Switch: React.ForwardRefExoticComponent<RNSwitchProps & NativeViewGestureHandlerProps & React.RefAttributes<React.ComponentType<any>>>;
-export declare type Switch = typeof Switch;
+export declare type Switch = typeof Switch & RNSwitch;
 export declare const TextInput: React.ForwardRefExoticComponent<RNTextInputProps & NativeViewGestureHandlerProps & React.RefAttributes<React.ComponentType<any>>>;
-export declare type TextInput = typeof TextInput;
+export declare type TextInput = typeof TextInput & RNTextInput;
 export declare const DrawerLayoutAndroid: React.ForwardRefExoticComponent<RNDrawerLayoutAndroidProps & {
     children?: React.ReactNode;
 } & NativeViewGestureHandlerProps & React.RefAttributes<React.ComponentType<any>>>;
-export declare type DrawerLayoutAndroid = typeof DrawerLayoutAndroid;
-export declare const FlatList: React.ForwardRefExoticComponent<RNFlatListProps<any> & React.RefAttributes<RNFlatList<any>>>;
-export declare type FlatList<ItemT> = React.ComponentType<RNFlatListProps<ItemT> & NativeViewGestureHandlerProps & React.RefAttributes<any>> & {
-    scrollToEnd: (params?: {
-        animated?: boolean;
-    }) => void;
-    scrollToIndex: (params: {
-        animated?: boolean;
-        index: number;
-        viewOffset?: number;
-        viewPosition?: number;
-    }) => void;
-    scrollToItem: (params: {
-        animated?: boolean;
-        item: ItemT;
-        viewPosition?: number;
-    }) => void;
-    scrollToOffset: (params: {
-        animated?: boolean;
-        offset: number;
-    }) => void;
-};
+export declare type DrawerLayoutAndroid = typeof DrawerLayoutAndroid & RNDrawerLayoutAndroid;
+export declare const FlatList: <ItemT = any>(props: React.PropsWithChildren<RNFlatListProps<ItemT> & React.RefAttributes<FlatList<ItemT>> & NativeViewGestureHandlerProps>, ref: React.ForwardedRef<FlatList<ItemT>>) => ReactElement | null;
+export declare type FlatList<ItemT = any> = typeof FlatList & RNFlatList<ItemT>;

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

@@ -1,31 +1,91 @@
 import * as React from 'react';
 import { Component } from 'react';
 import { Animated, StyleProp, ViewStyle } from 'react-native';
-import { PanGestureHandlerProps } from '../handlers/gestureHandlers';
+import { PanGestureHandlerProps } from '../handlers/PanGestureHandler';
 declare type SwipeableExcludes = Exclude<keyof PanGestureHandlerProps, 'onGestureEvent' | 'onHandlerStateChange'>;
-interface SwipeableProps extends Pick<PanGestureHandlerProps, SwipeableExcludes> {
+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;
+    /**
+     * 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 left action panel gets open.
+     */
     onSwipeableLeftOpen?: () => void;
+    /**
+     * Called when right action panel gets open.
+     */
     onSwipeableRightOpen?: () => void;
+    /**
+     * Called when action panel gets open (either right or left).
+     */
     onSwipeableOpen?: () => void;
+    /**
+     * Called when action panel is closed.
+     */
     onSwipeableClose?: () => void;
+    /**
+     * Called when left action panel starts animating on open.
+     */
     onSwipeableLeftWillOpen?: () => void;
+    /**
+     * Called when right action panel starts animating on open.
+     */
     onSwipeableRightWillOpen?: () => void;
+    /**
+     * Called when action panel starts animating on open (either right or left).
+     */
     onSwipeableWillOpen?: () => void;
+    /**
+     * Called when action panel starts animating on close.
+     */
     onSwipeableWillClose?: () => void;
     /**
      *
      * This map describes the values to use as inputRange for extra interpolation:
      * AnimatedValue: [startValue, endValue]
      *
-     * progressAnimatedValue: [0, 1]
-     * dragAnimatedValue: [0, +]
+     * progressAnimatedValue: [0, 1] dragAnimatedValue: [0, +]
      *
      * To support `rtl` flexbox layouts use `flexDirection` styling.
      * */
@@ -35,15 +95,22 @@ interface SwipeableProps extends Pick<PanGestureHandlerProps, SwipeableExcludes>
      * This map describes the values to use as inputRange for extra interpolation:
      * AnimatedValue: [startValue, endValue]
      *
-     * progressAnimatedValue: [0, 1]
-     * dragAnimatedValue: [0, -]
+     * progressAnimatedValue: [0, 1] dragAnimatedValue: [0, -]
      *
      * To support `rtl` flexbox layouts use `flexDirection` styling.
      * */
     renderRightActions?: (progressAnimatedValue: Animated.AnimatedInterpolation, dragAnimatedValue: Animated.AnimatedInterpolation) => React.ReactNode;
     useNativeAnimations?: boolean;
     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>;
 }
 declare type SwipeableState = {

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

@@ -1,7 +1,6 @@
-/// <reference types="node" />
 import { Component } from 'react';
 import { StyleProp, ViewStyle, TouchableWithoutFeedbackProps } from 'react-native';
-import { GestureEvent, HandlerStateChangeEvent } from '../../handlers/gestureHandlers';
+import { GestureEvent, HandlerStateChangeEvent } from '../../handlers/gestureHandlerCommon';
 import { NativeViewGestureHandlerPayload } from '../../handlers/NativeViewGestureHandler';
 import { TouchableNativeFeedbackExtraProps } from './TouchableNativeFeedback.android';
 /**
@@ -41,6 +40,7 @@ export default class GenericTouchable extends Component<GenericTouchableProps &
         delayLongPress: number;
         extraButtonProps: {
             rippleColor: string;
+            exclusive: boolean;
         };
     };
     pressInTimeout: Timeout;

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

@@ -20,6 +20,7 @@ export default class TouchableHighlight extends Component<TouchableHighlightProp
         delayLongPress: number;
         extraButtonProps: {
             rippleColor: string;
+            exclusive: boolean;
         };
     };
     constructor(props: TouchableHighlightProps & GenericTouchableProps);

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

@@ -10,6 +10,7 @@ export default class TouchableOpacity extends Component<TouchableOpacityProps &
         delayLongPress: number;
         extraButtonProps: {
             rippleColor: string;
+            exclusive: boolean;
         };
     };
     getChildStyleOpacityWithDefault: () => number;

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

@@ -0,0 +1,33 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare const flingGestureHandlerProps: readonly ["numberOfPointers", "direction"];
+export declare 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 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,43 @@
+import React from 'react';
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare const forceTouchGestureHandlerProps: readonly ["minForce", "maxForce", "feedbackOnActivation"];
+declare class ForceTouchFallback extends React.Component {
+    static forceTouchAvailable: boolean;
+    componentDidMount(): void;
+    render(): React.ReactNode;
+}
+export declare 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 declare type ForceTouchGestureHandler = typeof ForceTouchGestureHandler & {
+    forceTouchAvailable: boolean;
+};
+export declare const ForceTouchGestureHandler: typeof ForceTouchFallback | React.ComponentClass<ForceTouchGestureHandlerProps & React.RefAttributes<any>, any> | React.FunctionComponent<ForceTouchGestureHandlerProps & React.RefAttributes<any>>;
+export {};

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

@@ -0,0 +1,55 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare const longPressGestureHandlerProps: readonly ["minDurationMs", "maxDist"];
+export declare 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 root view. 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 root view. 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 type LongPressGestureHandler = typeof LongPressGestureHandler;
+export declare const LongPressGestureHandler: import("react").ComponentType<LongPressGestureHandlerProps & import("react").RefAttributes<any>>;

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

@@ -1,12 +1,27 @@
-/// <reference types="react" />
-import { BaseGestureHandlerProps } from './gestureHandlers';
-export interface NativeViewGestureHandlerProps extends BaseGestureHandlerProps<NativeViewGestureHandlerPayload> {
+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 declare type NativeViewGestureHandlerPayload = {
+    /**
+     * True if gesture was performed inside of containing view, false otherwise.
+     */
     pointerInside: boolean;
 };
-export declare const nativeViewProps: readonly ["id", "enabled", "minPointers", "waitFor", "simultaneousHandlers", "shouldCancelWhenOutside", "hitSlop", "onBegan", "onFailed", "onCancelled", "onActivated", "onEnded", "onGestureEvent", "onHandlerStateChange", "shouldActivateOnStart", "disallowInterruption"];
+export declare const nativeViewProps: readonly ["id", "enabled", "shouldCancelWhenOutside", "hitSlop", "waitFor", "simultaneousHandlers", "onBegan", "onFailed", "onCancelled", "onActivated", "onEnded", "onGestureEvent", "onHandlerStateChange", "shouldActivateOnStart", "disallowInterruption"];
 export declare 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,137 @@
+import { BaseGestureHandlerProps } from './gestureHandlerCommon';
+export declare const panGestureHandlerProps: readonly ["activeOffsetY", "activeOffsetX", "failOffsetY", "failOffsetX", "minDist", "minVelocity", "minVelocityX", "minVelocityY", "minPointers", "maxPointers", "avgTouches", "enableTrackpadTwoFingerGesture"];
+export declare const panGestureHandlerCustomNativeProps: readonly ["activeOffsetYStart", "activeOffsetYEnd", "activeOffsetXStart", "activeOffsetXEnd", "failOffsetYStart", "failOffsetYEnd", "failOffsetXStart", "failOffsetXEnd"];
+export declare 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 root view.
+     * 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 root view.
+     * 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;
+}
+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 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<"failOffsetXStart" | "failOffsetYStart" | "failOffsetXEnd" | "failOffsetYEnd" | "activeOffsetXStart" | "activeOffsetXEnd" | "activeOffsetYStart" | "activeOffsetYEnd", number>>;
+export {};