react-native-gesture-handler

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

const FlingGestureHandler: any;

const ForceTouchGestureHandler: any;

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

const GestureStateManager: GestureStateManagerType;

const LegacyDrawerLayoutAndroid: React.ComponentType<any>;

const LegacyRefreshControl: {
    (
        props: import('react-native').RefreshControlProps &
            NativeViewGestureHandlerProps & {
                ref?: React.Ref<React.ComponentType<any> | null> | undefined;
            }
    ): React.JSX.Element;
    displayName: any;
};

const LegacySwitch: {
    (
        props: RNSwitchProps &
            NativeViewGestureHandlerProps & {
                ref?: React.Ref<React.ComponentType<any> | null> | undefined;
            }
    ): React.JSX.Element;
    displayName: any;
};

const LegacyTextInput: {
    (
        props: RNTextInputProps &
            NativeViewGestureHandlerProps & {
                ref?: React.Ref<React.ComponentType<any> | null> | undefined;
            }
    ): React.JSX.Element;
    displayName: any;
};

const LongPressGestureHandler: any;

const NativeViewGestureHandler: any;

const PanGestureHandler: any;

const PinchGestureHandler: any;

const RefreshControl: React.ComponentType<any>;

const RotationGestureHandler: any;

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

const Switch: React.ComponentType<any>;

const TapGestureHandler: any;

const TextInput: React.ComponentType<any>;

const TouchableNativeFeedback: any;

BaseButton: (props: BaseButtonProps) => React.JSX.Element;

BorderlessButton: (props: BorderlessButtonProps) => React.JSX.Element;

FlatList: <ItemT = any>(
    props: PropsWithChildren<
        Omit<RNFlatListProps<ItemT>, 'renderScrollComponent' | 'ref'> & {
            disableReanimated?: boolean;
            useAnimated?: boolean;
            testID?: string;
        } & WithSharedValueRecursive<
                {
                    runOnJS?: boolean;
                    enabled?: boolean;
                    shouldCancelWhenOutside?: boolean;
                    hitSlop?:
                        | number
                        | Partial<
                              Record<
                                  | 'left'
                                  | 'right'
                                  | 'top'
                                  | 'bottom'
                                  | 'vertical'
                                  | 'horizontal',
                                  number
                              >
                          >
                        | Record<'left' | 'width', number>
                        | Record<'right' | 'width', number>
                        | Record<'top' | 'height', number>
                        | Record<'bottom' | 'height', number>
                        | CanonicalHitSlop;
                    activeCursor?: ActiveCursor;
                    mouseButton?: MouseButton;
                    cancelsTouchesInView?: boolean;
                    cancelsJSResponder?: boolean;
                    manualActivation?: boolean;
                },
                ActiveCursor | MouseButton
            > &
            GestureCallbacks<NativeHandlerData, NativeHandlerData> &
            NativeGestureNativeProperties &
            ExternalRelations &
            WrapperSpecificProperties<any>
    >
) => ReactElement | null;

GestureDetector: <
    TConfig,
    THandlerData,
    TExtendedHandlerData extends THandlerData
>(
    props:
        | NativeDetectorProps<TConfig, THandlerData, TExtendedHandlerData>
        | LegacyGestureDetectorProps
) => any;

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

InterceptingGestureDetector: <
    TConfig,
    THandlerData,
    TExtendedHandlerData extends THandlerData
>({
    gesture,
    children,
    touchAction,
    userSelect,
    enableContextMenu,
}: InterceptingGestureDetectorProps<
    TConfig,
    THandlerData,
    TExtendedHandlerData
>) => React.JSX.Element;

legacy_createNativeWrapper: <P>(
    Component: React.ComponentType<P>,
    config?: Readonly<NativeViewGestureHandlerProps>
) => {
    (
        props: P &
            NativeViewGestureHandlerProps & {
                ref?: React.Ref<React.ComponentType<any> | null> | undefined;
            }
    ): React.JSX.Element;
    displayName: any;
};

LegacyBaseButton: ({
    ref,
    ...props
}: Omit<LegacyBaseButtonProps, 'innerRef'> & {
    ref?: React.Ref<React.ComponentType<any>> | undefined;
}) => React.JSX.Element;

LegacyBorderlessButton: ({
    ref,
    ...props
}: Omit<LegacyBorderlessButtonProps, 'innerRef'> & {
    ref?: React.Ref<React.ComponentType<any>> | undefined;
}) => React.JSX.Element;

LegacyFlatList: <ItemT>(
    props: PropsWithChildren<
        Omit<RNFlatListProps<ItemT>, 'renderScrollComponent'> &
            NativeViewGestureHandlerProps & { ref?: React.Ref<any> }
    >
) => ReactElement | null;

LegacyPressable: (props: LegacyPressableProps) => React.JSX.Element;

LegacyRawButton: (
    props: Omit<
        React.ComponentProps<typeof LegacyRawButtonInner>,
        'needsOffscreenAlphaCompositing'
    >
) => React.JSX.Element;

LegacyRectButton: ({
    ref,
    ...props
}: Omit<LegacyRectButtonProps, 'innerRef'> & {
    ref?: React.Ref<React.ComponentType<any>> | undefined;
}) => React.JSX.Element;

LegacyScrollView: (
    props: RNScrollViewProps &
        NativeViewGestureHandlerProps & {
            ref?: React.Ref<React.ComponentRef<typeof RNScrollView> | null>;
        }
) => React.JSX.Element;

LegacyText: (props: TextProps) => React.JSX.Element;

Pressable: (props: PressableProps) => React.JSX.Element;

RawButton: (props: RawButtonProps) => React.JSX.Element;

RectButton: (props: RectButtonProps) => React.JSX.Element;

ScrollView: (
    props: RNScrollViewProps &
        NativeWrapperProperties<React.ComponentRef<typeof RNScrollView> | null>
) => React.JSX.Element;

Touchable: (props: TouchableProps) => React.JSX.Element;

TouchableWithoutFeedback: ({
    delayLongPress,
    extraButtonProps,
    ...rest
}: PropsWithChildren<TouchableWithoutFeedbackProps> & {
    ref?: React.Ref<GenericTouchable>;
}) => React.JSX.Element;

useCompetingGestures: (
    ...gestures: AnyGesture[]
) => import('../..').ComposedGesture;

useExclusiveGestures: (
    ...gestures: AnyGesture[]
) => import('../..').ComposedGesture;

useFlingGesture: (config?: FlingGestureConfig) => FlingGesture;

useHoverGesture: (config?: HoverGestureConfig) => HoverGesture;

useLongPressGesture: (config?: LongPressGestureConfig) => LongPressGesture;

useManualGesture: (config?: ManualGestureConfig) => ManualGesture;

useNativeGesture: (config?: NativeGestureConfig) => NativeGesture;

usePanGesture: (config?: PanGestureConfig) => PanGesture;

usePinchGesture: (config?: PinchGestureConfig) => PinchGesture;

useRotationGesture: (config?: RotationGestureConfig) => RotationGesture;

useSimultaneousGestures: (
    ...gestures: AnyGesture[]
) => import('../..').ComposedGesture;

useTapGesture: (config?: TapGestureConfig) => TapGesture;

VirtualGestureDetector: <
    TConfig,
    THandlerData,
    TExtendedHandlerData extends THandlerData
>(
    props: VirtualDetectorProps<TConfig, THandlerData, TExtendedHandlerData>
) => any;

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

type ComposedGesture = {
    handlerTags: number[];
    type: ComposedGestureName;
    config: ComposedGestureConfig;
    detectorCallbacks: DetectorCallbacks<unknown, unknown>;
    externalSimultaneousHandlers: number[];
    gestures: Gesture[];
};

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

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

type FlingGesture = SingleGesture<FlingGestureProperties, FlingHandlerData>;

type FlingGestureActiveEvent = FlingGestureEvent;

type FlingGestureConfig = ExcludeInternalConfigProps<FlingGestureInternalConfig>;

type FlingGestureEvent = GestureEvent<FlingHandlerData>;

type FlingGestureHandler = typeof FlingGestureHandler;

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

type FlingGestureHandlerGestureEvent = GestureEvent<FlingGestureHandlerEventPayload>;

type FlingGestureHandlerProperties = FlingGestureHandlerProps;

type FlingGestureHandlerStateChangeEvent =
    HandlerStateChangeEvent<FlingGestureHandlerEventPayload>;

type ForceTouchGestureChangeEventPayload = {
    forceChange: number;
};

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

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

type ForceTouchGestureHandlerGestureEvent =
    GestureEvent<ForceTouchGestureHandlerEventPayload>;