@rootnative/inertia-gestures 0.0.0-alpha.0

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+All notable changes to `@rootnative/inertia-gestures` are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Pre-`1.0`, breaking changes may land in minor versions and are called out under their release.
+
+This package ships in lockstep with `@rootnative/inertia` — version numbers track the core release that introduced or last touched the adapter.
+
+## [Unreleased]
+
+## [0.0.0-alpha.0]
+
+Initial alpha publish alongside `@rootnative/inertia@0.0.0-alpha.0`. Optional adapter package wrapping `react-native-gesture-handler`; the core library has no required gesture-handler dependency.
+
+### Added
+
+- `useDrag({ onRelease })` — release worklet returns per-axis Inertia transitions (snap-to-tick spring, decay with bounds, etc.). Velocity stays on the UI thread; no JS round-trip.
+- `useSwipe`, `usePan` hooks composable with any `Motion.*` primitive via `<GestureDetector>`.
+
+[unreleased]: https://github.com/rootnative/inertia/compare/v0.0.0-alpha.0...HEAD
+[0.0.0-alpha.0]: https://github.com/rootnative/inertia/releases/tag/v0.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RootNative
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+# @rootnative/inertia-gestures
+
+[![npm](https://img.shields.io/npm/v/@rootnative/inertia-gestures.svg)](https://www.npmjs.com/package/@rootnative/inertia-gestures)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+
+Drag / pan / swipe hooks for [`@rootnative/inertia`](../core), built on [`react-native-gesture-handler`](https://docs.swmansion.com/react-native-gesture-handler/). Optional sibling package — install only when you need richer-than-`pressable` gestures. The core library has no required `gesture-handler` dependency.
+
+The hooks compose with any `Motion.*` primitive via a `<GestureDetector>` and a single `style` slot — they don't replace the core `gesture` prop, they extend what's reachable beside it.
+
+## Install
+
+```sh
+pnpm add @rootnative/inertia-gestures react-native-gesture-handler
+```
+
+Then follow the [`react-native-gesture-handler` install guide](https://docs.swmansion.com/react-native-gesture-handler/docs/installation) — it needs `<GestureHandlerRootView>` near the root of your app.
+
+**Peer dependencies:** `@rootnative/inertia` (workspace or installed), `react >=19.0.0`, `react-native >=0.81.0`, `react-native-reanimated >=4.0.0`, `react-native-gesture-handler >=2.0.0`.
+
+## What ships
+
+- **`useDrag`** — one- or two-axis drag with optional bounds and rubber-band overshoot. Accepts an `onRelease` worklet that returns per-axis Inertia release transitions (snap-to-tick spring, decay with bounds, etc.). The release velocity stays on the UI thread — no JS round-trip.
+- **`usePan`** — camera-style pan with momentum on release.
+- **`useSwipe`** — directional commit-or-snap-back (distance + velocity thresholds).
+
+## Usage
+
+```tsx
+import { GestureDetector } from 'react-native-gesture-handler'
+import { Motion } from '@rootnative/inertia'
+import { useDrag } from '@rootnative/inertia-gestures'
+
+function DraggableBox() {
+  const drag = useDrag({
+    axis: 'both',
+    bounds: { left: -120, right: 120, top: -120, bottom: 120 },
+  })
+
+  return (
+    <GestureDetector gesture={drag.gesture}>
+      <Motion.View style={drag.style} />
+    </GestureDetector>
+  )
+}
+```
+
+## Documentation
+
+- Full docs: [https://rootnative.github.io/inertia/docs/gestures-adapter](https://rootnative.github.io/inertia/docs/gestures-adapter)
+- Core library: [`@rootnative/inertia`](../core)
+
+## License
+
+[MIT](./LICENSE) © RootNative

package/dist/index.d.mts

@@ -0,0 +1,250 @@
+import { PanGesture } from 'react-native-gesture-handler';
+import { useAnimatedStyle, SharedValue } from 'react-native-reanimated';
+import { SpringTransition, TimingTransition, DecayTransition, NoAnimationTransition } from '@rootnative/inertia';
+
+/**
+ * Public types for `@rootnative/inertia-gestures`.
+ */
+
+/**
+ * Bounds the dragged value can reach. Each side is optional — omit to leave
+ * that direction unbounded. Coordinates are in the same space the drag
+ * publishes (pixels of translation from the dragged element's resting
+ * position), so `{ left: -100, right: 100 }` allows ±100 px of horizontal
+ * travel.
+ */
+interface DragConstraints {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+}
+/**
+ * UI-thread payload delivered to `onRelease` when the drag finishes. `x` and
+ * `y` are the final translations the SVs are sitting at; `velocity.x` /
+ * `velocity.y` are the release velocities in px/sec.
+ */
+interface ReleaseInfo {
+    x: number;
+    y: number;
+    velocity: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Per-axis release transition. Spring / timing / no-animation animate to a
+ * target value (`to`); decay decelerates from the current position via its
+ * own physics and has no `to`. Pass the release velocity from `ReleaseInfo`
+ * into the transition's own `velocity` field for natural continuation.
+ */
+type ReleaseTransition = (SpringTransition & {
+    to: number;
+}) | (TimingTransition & {
+    to: number;
+}) | DecayTransition | (NoAnimationTransition & {
+    to: number;
+});
+/**
+ * Per-axis release transitions returned by `onRelease`. Omit an axis to leave
+ * its SV where it landed (no release animation on that axis).
+ */
+interface ReleaseResult {
+    x?: ReleaseTransition;
+    y?: ReleaseTransition;
+}
+/**
+ * Configuration for `useDrag`. All fields are optional; the defaults give an
+ * unconstrained two-axis drag with no elasticity.
+ */
+interface DragOptions {
+    /**
+     * Restrict the drag to one axis. Defaults to `'both'`. When `'x'` is set
+     * the y-axis shared value never updates (and vice versa); the gesture
+     * still tracks both for velocity reporting on `onDragEnd`.
+     */
+    axis?: 'x' | 'y' | 'both';
+    /**
+     * Travel bounds. Out-of-bounds values clamp to the limit unless `elastic`
+     * is non-zero, in which case overshoot is dampened (rubber-band feel).
+     */
+    constraints?: DragConstraints;
+    /**
+     * Rubber-band coefficient applied to overshoot past `constraints`. `0`
+     * (default) hard-clamps; `1` is fully elastic (no resistance). Typical
+     * Framer-Motion-style feel sits around `0.2`–`0.4`.
+     */
+    elastic?: number;
+    /**
+     * Fired on the JS thread when the drag begins.
+     */
+    onDragStart?: () => void;
+    /**
+     * Fired on the JS thread when the drag finishes (release or cancel). The
+     * payload is the final translation and the release velocity in px/sec.
+     */
+    onDragEnd?: (info: ReleaseInfo) => void;
+    /**
+     * UI-thread callback fired on release. Return per-axis release transitions
+     * to animate the SVs to a settled position via Inertia's transition
+     * resolver — spring snap-to-tick, decay with bounds, timing settle, etc.
+     * Omit an axis (or return nothing) to leave that SV where it landed.
+     *
+     * This callback runs as a worklet so the release velocity stays on the UI
+     * thread. Author it with the `'worklet'` directive at the top of the body.
+     *
+     * Composes with `onDragEnd`: both fire on release. `onRelease` controls SV
+     * animation on the UI thread; `onDragEnd` is for JS-thread side effects
+     * (analytics, state updates).
+     */
+    onRelease?: (info: ReleaseInfo) => ReleaseResult | void;
+}
+
+interface UseDragResult {
+    /** Pan gesture to pass to a `<GestureDetector>`. */
+    gesture: PanGesture;
+    /**
+     * Animated style fragment (a single `transform` entry) to stack onto the
+     * dragged Motion primitive's `style` prop. Stable across renders.
+     */
+    animatedStyle: ReturnType<typeof useAnimatedStyle>;
+    /** Current x translation in pixels. UI-thread shared value. */
+    dragX: SharedValue<number>;
+    /** Current y translation in pixels. UI-thread shared value. */
+    dragY: SharedValue<number>;
+    /** True while the gesture is active. */
+    isDragging: SharedValue<boolean>;
+}
+/**
+ * Drag a Motion primitive with `react-native-gesture-handler`'s pan gesture.
+ *
+ * The hook owns a pair of shared values (`dragX`, `dragY`) and a `Pan`
+ * gesture that updates them on the UI thread. The returned `animatedStyle`
+ * is a self-contained `transform: [{ translateX }, { translateY }]` fragment;
+ * stack it onto the dragged component without colliding with Motion's own
+ * `animate` transforms.
+ *
+ * Usage:
+ * ```tsx
+ * const drag = useDrag({ axis: 'x', constraints: { left: -100, right: 100 } })
+ * return (
+ *   <GestureDetector gesture={drag.gesture}>
+ *     <Motion.View style={drag.animatedStyle} />
+ *   </GestureDetector>
+ * )
+ * ```
+ */
+declare function useDrag(options?: DragOptions): UseDragResult;
+
+type SwipeDirection = 'left' | 'right' | 'up' | 'down';
+interface SwipeOptions {
+    /**
+     * Allowed swipe directions. Defaults to all four. The gesture only commits
+     * for directions in this list — a horizontal swipe with `directions:
+     * ['up', 'down']` will not fire `onSwipe`.
+     */
+    directions?: SwipeDirection[];
+    /**
+     * Pixel distance threshold past which a release commits the swipe. Defaults
+     * to `80`.
+     */
+    distanceThreshold?: number;
+    /**
+     * Velocity threshold (px/sec) past which a release commits the swipe even
+     * before the distance threshold is reached — flick-style gestures. Defaults
+     * to `800`.
+     */
+    velocityThreshold?: number;
+    /**
+     * Fired on the JS thread when the gesture commits in an allowed direction.
+     */
+    onSwipe?: (direction: SwipeDirection, info: {
+        distance: number;
+        velocity: number;
+    }) => void;
+}
+interface UseSwipeResult {
+    /** Pan gesture to pass to a `<GestureDetector>`. */
+    gesture: PanGesture;
+    /**
+     * Animated style fragment exposing live translation while the gesture is
+     * active. Snaps back to `{ 0, 0 }` after release (whether or not the swipe
+     * committed) via a default spring.
+     */
+    animatedStyle: ReturnType<typeof useAnimatedStyle>;
+    /** Live x translation. */
+    swipeX: SharedValue<number>;
+    /** Live y translation. */
+    swipeY: SharedValue<number>;
+    /** True while the user is actively swiping. */
+    isActive: SharedValue<boolean>;
+}
+/**
+ * Directional commit-or-snap-back gesture. Tracks live translation while the
+ * user drags and fires `onSwipe(direction)` on release if either the distance
+ * or velocity threshold is exceeded in an allowed direction. The position
+ * shared values always animate back to zero — the consumer is responsible
+ * for whatever side effect the commit drives (delete a row, dismiss a sheet,
+ * etc.).
+ *
+ * Usage:
+ * ```tsx
+ * const swipe = useSwipe({
+ *   directions: ['left'],
+ *   onSwipe: (dir) => deleteRow(),
+ * })
+ * return (
+ *   <GestureDetector gesture={swipe.gesture}>
+ *     <Motion.View style={swipe.animatedStyle}>...</Motion.View>
+ *   </GestureDetector>
+ * )
+ * ```
+ */
+declare function useSwipe(options?: SwipeOptions): UseSwipeResult;
+
+interface PanOptions {
+    /**
+     * Translation bounds. Each side is optional; out-of-bounds motion during
+     * the active gesture and during the post-release decay is hard-clamped
+     * (Reanimated's `withDecay` `clamp` param). Decay-style overshoot is not
+     * supported here — for rubber-banded bounds, prefer `useDrag` with
+     * `elastic`.
+     */
+    constraints?: DragConstraints;
+    /**
+     * Deceleration applied to the post-release momentum. Higher = momentum
+     * dies faster. Reanimated default is `0.998`; lower values feel more
+     * "slippy". Range: roughly `0.99` (slow) to `0.999` (long glide).
+     */
+    deceleration?: number;
+    /**
+     * Disable the post-release momentum entirely. Defaults to `false` — pan
+     * coasts after release. Set to `true` for a hard stop on release (drag-like
+     * behavior).
+     */
+    disableMomentum?: boolean;
+}
+interface UsePanResult {
+    /** Pan gesture to pass to a `<GestureDetector>`. */
+    gesture: PanGesture;
+    /** Stable animated `transform` style. */
+    animatedStyle: ReturnType<typeof useAnimatedStyle>;
+    /** Live x translation, persistent across gestures. */
+    panX: SharedValue<number>;
+    /** Live y translation, persistent across gestures. */
+    panY: SharedValue<number>;
+    /** True while the user is actively panning. Decay phase reads `false`. */
+    isPanning: SharedValue<boolean>;
+}
+/**
+ * Camera-pan-style drag with momentum on release. Translation persists
+ * across separate pan gestures (the next pan starts from the current
+ * position, not zero), and on release the translation continues to glide
+ * via Reanimated's `withDecay` until friction stops it.
+ *
+ * Use for map / zoom-canvas / large-image navigation. For dragging an
+ * element to a position with no momentum, use `useDrag` instead.
+ */
+declare function usePan(options?: PanOptions): UsePanResult;
+
+export { type DragConstraints, type DragOptions, type PanOptions, type ReleaseInfo, type ReleaseResult, type ReleaseTransition, type SwipeDirection, type SwipeOptions, type UseDragResult, type UsePanResult, type UseSwipeResult, useDrag, usePan, useSwipe };

package/dist/index.d.ts

@@ -0,0 +1,250 @@
+import { PanGesture } from 'react-native-gesture-handler';
+import { useAnimatedStyle, SharedValue } from 'react-native-reanimated';
+import { SpringTransition, TimingTransition, DecayTransition, NoAnimationTransition } from '@rootnative/inertia';
+
+/**
+ * Public types for `@rootnative/inertia-gestures`.
+ */
+
+/**
+ * Bounds the dragged value can reach. Each side is optional — omit to leave
+ * that direction unbounded. Coordinates are in the same space the drag
+ * publishes (pixels of translation from the dragged element's resting
+ * position), so `{ left: -100, right: 100 }` allows ±100 px of horizontal
+ * travel.
+ */
+interface DragConstraints {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+}
+/**
+ * UI-thread payload delivered to `onRelease` when the drag finishes. `x` and
+ * `y` are the final translations the SVs are sitting at; `velocity.x` /
+ * `velocity.y` are the release velocities in px/sec.
+ */
+interface ReleaseInfo {
+    x: number;
+    y: number;
+    velocity: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Per-axis release transition. Spring / timing / no-animation animate to a
+ * target value (`to`); decay decelerates from the current position via its
+ * own physics and has no `to`. Pass the release velocity from `ReleaseInfo`
+ * into the transition's own `velocity` field for natural continuation.
+ */
+type ReleaseTransition = (SpringTransition & {
+    to: number;
+}) | (TimingTransition & {
+    to: number;
+}) | DecayTransition | (NoAnimationTransition & {
+    to: number;
+});
+/**
+ * Per-axis release transitions returned by `onRelease`. Omit an axis to leave
+ * its SV where it landed (no release animation on that axis).
+ */
+interface ReleaseResult {
+    x?: ReleaseTransition;
+    y?: ReleaseTransition;
+}
+/**
+ * Configuration for `useDrag`. All fields are optional; the defaults give an
+ * unconstrained two-axis drag with no elasticity.
+ */
+interface DragOptions {
+    /**
+     * Restrict the drag to one axis. Defaults to `'both'`. When `'x'` is set
+     * the y-axis shared value never updates (and vice versa); the gesture
+     * still tracks both for velocity reporting on `onDragEnd`.
+     */
+    axis?: 'x' | 'y' | 'both';
+    /**
+     * Travel bounds. Out-of-bounds values clamp to the limit unless `elastic`
+     * is non-zero, in which case overshoot is dampened (rubber-band feel).
+     */
+    constraints?: DragConstraints;
+    /**
+     * Rubber-band coefficient applied to overshoot past `constraints`. `0`
+     * (default) hard-clamps; `1` is fully elastic (no resistance). Typical
+     * Framer-Motion-style feel sits around `0.2`–`0.4`.
+     */
+    elastic?: number;
+    /**
+     * Fired on the JS thread when the drag begins.
+     */
+    onDragStart?: () => void;
+    /**
+     * Fired on the JS thread when the drag finishes (release or cancel). The
+     * payload is the final translation and the release velocity in px/sec.
+     */
+    onDragEnd?: (info: ReleaseInfo) => void;
+    /**
+     * UI-thread callback fired on release. Return per-axis release transitions
+     * to animate the SVs to a settled position via Inertia's transition
+     * resolver — spring snap-to-tick, decay with bounds, timing settle, etc.
+     * Omit an axis (or return nothing) to leave that SV where it landed.
+     *
+     * This callback runs as a worklet so the release velocity stays on the UI
+     * thread. Author it with the `'worklet'` directive at the top of the body.
+     *
+     * Composes with `onDragEnd`: both fire on release. `onRelease` controls SV
+     * animation on the UI thread; `onDragEnd` is for JS-thread side effects
+     * (analytics, state updates).
+     */
+    onRelease?: (info: ReleaseInfo) => ReleaseResult | void;
+}
+
+interface UseDragResult {
+    /** Pan gesture to pass to a `<GestureDetector>`. */
+    gesture: PanGesture;
+    /**
+     * Animated style fragment (a single `transform` entry) to stack onto the
+     * dragged Motion primitive's `style` prop. Stable across renders.
+     */
+    animatedStyle: ReturnType<typeof useAnimatedStyle>;
+    /** Current x translation in pixels. UI-thread shared value. */
+    dragX: SharedValue<number>;
+    /** Current y translation in pixels. UI-thread shared value. */
+    dragY: SharedValue<number>;
+    /** True while the gesture is active. */
+    isDragging: SharedValue<boolean>;
+}
+/**
+ * Drag a Motion primitive with `react-native-gesture-handler`'s pan gesture.
+ *
+ * The hook owns a pair of shared values (`dragX`, `dragY`) and a `Pan`
+ * gesture that updates them on the UI thread. The returned `animatedStyle`
+ * is a self-contained `transform: [{ translateX }, { translateY }]` fragment;
+ * stack it onto the dragged component without colliding with Motion's own
+ * `animate` transforms.
+ *
+ * Usage:
+ * ```tsx
+ * const drag = useDrag({ axis: 'x', constraints: { left: -100, right: 100 } })
+ * return (
+ *   <GestureDetector gesture={drag.gesture}>
+ *     <Motion.View style={drag.animatedStyle} />
+ *   </GestureDetector>
+ * )
+ * ```
+ */
+declare function useDrag(options?: DragOptions): UseDragResult;
+
+type SwipeDirection = 'left' | 'right' | 'up' | 'down';
+interface SwipeOptions {
+    /**
+     * Allowed swipe directions. Defaults to all four. The gesture only commits
+     * for directions in this list — a horizontal swipe with `directions:
+     * ['up', 'down']` will not fire `onSwipe`.
+     */
+    directions?: SwipeDirection[];
+    /**
+     * Pixel distance threshold past which a release commits the swipe. Defaults
+     * to `80`.
+     */
+    distanceThreshold?: number;
+    /**
+     * Velocity threshold (px/sec) past which a release commits the swipe even
+     * before the distance threshold is reached — flick-style gestures. Defaults
+     * to `800`.
+     */
+    velocityThreshold?: number;
+    /**
+     * Fired on the JS thread when the gesture commits in an allowed direction.
+     */
+    onSwipe?: (direction: SwipeDirection, info: {
+        distance: number;
+        velocity: number;
+    }) => void;
+}
+interface UseSwipeResult {
+    /** Pan gesture to pass to a `<GestureDetector>`. */
+    gesture: PanGesture;
+    /**
+     * Animated style fragment exposing live translation while the gesture is
+     * active. Snaps back to `{ 0, 0 }` after release (whether or not the swipe
+     * committed) via a default spring.
+     */
+    animatedStyle: ReturnType<typeof useAnimatedStyle>;
+    /** Live x translation. */
+    swipeX: SharedValue<number>;
+    /** Live y translation. */
+    swipeY: SharedValue<number>;
+    /** True while the user is actively swiping. */
+    isActive: SharedValue<boolean>;
+}
+/**
+ * Directional commit-or-snap-back gesture. Tracks live translation while the
+ * user drags and fires `onSwipe(direction)` on release if either the distance
+ * or velocity threshold is exceeded in an allowed direction. The position
+ * shared values always animate back to zero — the consumer is responsible
+ * for whatever side effect the commit drives (delete a row, dismiss a sheet,
+ * etc.).
+ *
+ * Usage:
+ * ```tsx
+ * const swipe = useSwipe({
+ *   directions: ['left'],
+ *   onSwipe: (dir) => deleteRow(),
+ * })
+ * return (
+ *   <GestureDetector gesture={swipe.gesture}>
+ *     <Motion.View style={swipe.animatedStyle}>...</Motion.View>
+ *   </GestureDetector>
+ * )
+ * ```
+ */
+declare function useSwipe(options?: SwipeOptions): UseSwipeResult;
+
+interface PanOptions {
+    /**
+     * Translation bounds. Each side is optional; out-of-bounds motion during
+     * the active gesture and during the post-release decay is hard-clamped
+     * (Reanimated's `withDecay` `clamp` param). Decay-style overshoot is not
+     * supported here — for rubber-banded bounds, prefer `useDrag` with
+     * `elastic`.
+     */
+    constraints?: DragConstraints;
+    /**
+     * Deceleration applied to the post-release momentum. Higher = momentum
+     * dies faster. Reanimated default is `0.998`; lower values feel more
+     * "slippy". Range: roughly `0.99` (slow) to `0.999` (long glide).
+     */
+    deceleration?: number;
+    /**
+     * Disable the post-release momentum entirely. Defaults to `false` — pan
+     * coasts after release. Set to `true` for a hard stop on release (drag-like
+     * behavior).
+     */
+    disableMomentum?: boolean;
+}
+interface UsePanResult {
+    /** Pan gesture to pass to a `<GestureDetector>`. */
+    gesture: PanGesture;
+    /** Stable animated `transform` style. */
+    animatedStyle: ReturnType<typeof useAnimatedStyle>;
+    /** Live x translation, persistent across gestures. */
+    panX: SharedValue<number>;
+    /** Live y translation, persistent across gestures. */
+    panY: SharedValue<number>;
+    /** True while the user is actively panning. Decay phase reads `false`. */
+    isPanning: SharedValue<boolean>;
+}
+/**
+ * Camera-pan-style drag with momentum on release. Translation persists
+ * across separate pan gestures (the next pan starts from the current
+ * position, not zero), and on release the translation continues to glide
+ * via Reanimated's `withDecay` until friction stops it.
+ *
+ * Use for map / zoom-canvas / large-image navigation. For dragging an
+ * element to a position with no momentum, use `useDrag` instead.
+ */
+declare function usePan(options?: PanOptions): UsePanResult;
+
+export { type DragConstraints, type DragOptions, type PanOptions, type ReleaseInfo, type ReleaseResult, type ReleaseTransition, type SwipeDirection, type SwipeOptions, type UseDragResult, type UsePanResult, type UseSwipeResult, useDrag, usePan, useSwipe };