react-native-gtkx 0.2.0-alpha.2 → 0.3.0-alpha.1

package/dist/dnd/types.js

@@ -0,0 +1,25 @@
+// --- draggable --------------------------------------------------------------
+export var DraggableState;
+(function (DraggableState) {
+    DraggableState["IDLE"] = "IDLE";
+    DraggableState["DRAGGING"] = "DRAGGING";
+    DraggableState["DROPPED"] = "DROPPED";
+})(DraggableState || (DraggableState = {}));
+export var ScrollDirection;
+(function (ScrollDirection) {
+    ScrollDirection["None"] = "none";
+    ScrollDirection["Up"] = "up";
+    ScrollDirection["Down"] = "down";
+})(ScrollDirection || (ScrollDirection = {}));
+export var HorizontalScrollDirection;
+(function (HorizontalScrollDirection) {
+    HorizontalScrollDirection["None"] = "none";
+    HorizontalScrollDirection["Left"] = "left";
+    HorizontalScrollDirection["Right"] = "right";
+})(HorizontalScrollDirection || (HorizontalScrollDirection = {}));
+export var SortableDirection;
+(function (SortableDirection) {
+    SortableDirection["Vertical"] = "vertical";
+    SortableDirection["Horizontal"] = "horizontal";
+})(SortableDirection || (SortableDirection = {}));
+//# sourceMappingURL=types.js.map

package/dist/dnd/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/dnd/types.ts"],"names":[],"mappings":"AAwBA,+EAA+E;AAE/E,MAAM,CAAN,IAAY,cAIX;AAJD,WAAY,cAAc;IACxB,+BAAa,CAAA;IACb,uCAAqB,CAAA;IACrB,qCAAmB,CAAA;AACrB,CAAC,EAJW,cAAc,KAAd,cAAc,QAIzB;AAqKD,MAAM,CAAN,IAAY,eAIX;AAJD,WAAY,eAAe;IACzB,gCAAa,CAAA;IACb,4BAAS,CAAA;IACT,gCAAa,CAAA;AACf,CAAC,EAJW,eAAe,KAAf,eAAe,QAI1B;AAED,MAAM,CAAN,IAAY,yBAIX;AAJD,WAAY,yBAAyB;IACnC,0CAAa,CAAA;IACb,0CAAa,CAAA;IACb,4CAAe,CAAA;AACjB,CAAC,EAJW,yBAAyB,KAAzB,yBAAyB,QAIpC;AAED,MAAM,CAAN,IAAY,iBAGX;AAHD,WAAY,iBAAiB;IAC3B,0CAAqB,CAAA;IACrB,8CAAyB,CAAA;AAC3B,CAAC,EAHW,iBAAiB,KAAjB,iBAAiB,QAG5B","sourcesContent":["// The mirrored type surface of `react-native-reanimated-dnd`, name for name.\n//\n// WHY the names are copied rather than improved: the point of this subpath\n// is that an app which already uses that library keeps its source. A better\n// name here would be a worse module — see docs/research/drag-and-drop.md.\nimport type { ReactNode, RefObject } from \"react\"\nimport type { StyleProp } from \"../contracts\"\n\n/**\n * What `SharedValue<T>` degrades to here.\n *\n * Reanimated's `SharedValue<T>` is `{ value: T }` plus the worklet plumbing\n * that makes writes cross to the UI thread. There is no UI thread on this\n * platform, so this is the same box without the crossing: **reads and\n * writes both work**, they just do not drive an animation.\n *\n * That matters more than it looks. `positions`, `lowerBound`,\n * `autoScrollDirection` and `itemHeights` appear in\n * `SortableRenderItemProps` — public API an app forwards with `{...rest}`\n * and, occasionally, reads. Typing them as an opaque token would break the\n * reads; typing them as this keeps them working.\n */\nexport type SharedValueLike<T> = { value: T }\n\n// --- draggable --------------------------------------------------------------\n\nexport enum DraggableState {\n  IDLE = \"IDLE\",\n  DRAGGING = \"DRAGGING\",\n  DROPPED = \"DROPPED\",\n}\n\nexport type AnimationFunction = (toValue: number) => number\n\nexport type CollisionAlgorithm = \"center\" | \"intersect\" | \"contain\"\n\nexport interface UseDraggableOptions<TData = unknown> {\n  data: TData\n  draggableId?: string\n  dragDisabled?: boolean\n  onDragStart?: (data: TData) => void\n  onDragEnd?: (data: TData) => void\n  onDragging?: (payload: {\n    x: number\n    y: number\n    tx: number\n    ty: number\n    itemData: TData\n  }) => void\n  onStateChange?: (state: DraggableState) => void\n  /**\n   * Accepted and ignored. Upstream uses it to tell a tap from a drag; GDK\n   * already does that with `gtk-dnd-drag-threshold` before it starts a drag\n   * at all, so honouring it would only make dragging feel slower.\n   */\n  preDragDelay?: number\n  /**\n   * Accepted and ignored. GDK hit-tests the pointer against the real widget\n   * tree; of the three upstream algorithms `\"center\"` is closest, since the\n   * drag icon is carried at the point it was grabbed.\n   */\n  collisionAlgorithm?: CollisionAlgorithm\n  /** Unsupported: the compositor carries the drag icon and nothing here can\n   *  constrain its path. Kept in the type so a shared file still compiles\n   *  for iOS and Android. */\n  dragAxis?: \"x\" | \"y\" | \"both\"\n  /** Unsupported, same reason as `dragAxis`. */\n  dragBoundsRef?: RefObject<unknown>\n  /** Unsupported: there is no return animation, because the view never\n   *  left — GDK drew a picture of it instead. */\n  animationFunction?: AnimationFunction\n}\n\nexport interface UseDraggableReturn {\n  /** Spread onto the view that should be draggable. Upstream's name for it\n   *  is `animatedViewProps`; the props are a `style` and the drag\n   *  controllers, which on this platform are React children rather than a\n   *  style. */\n  animatedViewProps: {\n    style?: StyleProp\n    children: ReactNode\n  }\n  state: DraggableState\n  hasHandle: boolean\n  registerHandle: (registered: boolean) => void\n}\n\nexport interface DraggableProps<\n  TData = unknown,\n> extends UseDraggableOptions<TData> {\n  style?: StyleProp\n  children: ReactNode\n  testID?: string\n}\n\nexport interface DraggableHandleProps {\n  children: ReactNode\n  style?: StyleProp\n  testID?: string\n}\n\n// --- droppable --------------------------------------------------------------\n\nexport type DropAlignment =\n  | \"center\"\n  | \"top-left\"\n  | \"top-center\"\n  | \"top-right\"\n  | \"center-left\"\n  | \"center-right\"\n  | \"bottom-left\"\n  | \"bottom-center\"\n  | \"bottom-right\"\n\nexport interface DropOffset {\n  x: number\n  y: number\n}\n\nexport interface UseDroppableOptions<TData = unknown> {\n  onDrop: (data: TData) => void\n  dropDisabled?: boolean\n  onActiveChange?: (isActive: boolean) => void\n  activeStyle?: StyleProp\n  droppableId?: string\n  /** How many draggables this zone accepts. When it is full GDK is told to\n   *  REFUSE the drop, so the pointer shows the no-drop cursor — upstream\n   *  silently skips the slot instead. */\n  capacity?: number\n  /** Unsupported: both of these place the dragged view inside the zone\n   *  after the drop, and the view never moved. */\n  dropAlignment?: DropAlignment\n  dropOffset?: DropOffset\n}\n\nexport interface UseDroppableReturn {\n  viewProps: {\n    style?: StyleProp\n    children: ReactNode\n  }\n  isActive: boolean\n  activeStyle?: StyleProp\n}\n\nexport interface DroppableProps<\n  TData = unknown,\n> extends UseDroppableOptions<TData> {\n  style?: StyleProp\n  children: ReactNode\n  testID?: string\n}\n\n// --- context ----------------------------------------------------------------\n\nexport interface DroppedItemsMap<TData = unknown> {\n  [draggableId: string]: { droppableId: string; data: TData }\n}\n\nexport interface DropProviderProps {\n  children: ReactNode\n  onDroppedItemsUpdate?: (droppedItems: DroppedItemsMap) => void\n  onDragStart?: (data: unknown) => void\n  onDragEnd?: (data: unknown) => void\n  onDragging?: (payload: {\n    x: number\n    y: number\n    tx: number\n    ty: number\n    itemData: unknown\n  }) => void\n  /** Accepted and ignored: there is no layout pass to complete, because\n   *  nothing caches a slot rectangle. See `requestPositionUpdate`. */\n  onLayoutUpdateComplete?: () => void\n  style?: StyleProp\n  testID?: string\n  ref?: RefObject<DropProviderRef | null>\n}\n\nexport interface DropProviderRef {\n  /**\n   * A no-op **because GDK re-hit-tests on every motion**. Upstream needs it\n   * to refresh cached slot rectangles after a scroll or a relayout; there\n   * are no cached rectangles here, so calling it is harmless and\n   * unnecessary. Kept so an app that calls it after a list update compiles.\n   */\n  requestPositionUpdate: () => void\n  getDroppedItems: () => DroppedItemsMap\n}\n\n// --- sortable ---------------------------------------------------------------\n\nexport interface SortableData {\n  id: string\n}\n\nexport enum ScrollDirection {\n  None = \"none\",\n  Up = \"up\",\n  Down = \"down\",\n}\n\nexport enum HorizontalScrollDirection {\n  None = \"none\",\n  Left = \"left\",\n  Right = \"right\",\n}\n\nexport enum SortableDirection {\n  Vertical = \"vertical\",\n  Horizontal = \"horizontal\",\n}\n\n/** The plumbing `Sortable` hands `renderItem` and `renderItem` hands\n *  `SortableItem` — opaque in upstream's own examples, which destructure\n *  `item`/`index`/`id` and spread the rest. */\nexport interface SortableItemPlumbing {\n  positions: SharedValueLike<Record<string, number>>\n  lowerBound: SharedValueLike<number>\n  autoScrollDirection: SharedValueLike<ScrollDirection>\n  itemHeights: SharedValueLike<Record<string, number>>\n  itemsCount: number\n  /** Accepted and ignored: Yoga lays rows out at their natural height, so\n   *  a height hint has nothing to correct. */\n  itemHeight?: number\n  /** Accepted and ignored, same reason. */\n  estimatedItemHeight?: number\n  /**\n   * Accepted and ignored. Upstream needs the container's height to know\n   * when a dragged row has reached an edge and autoscroll should start;\n   * there is no autoscroll here (docs/research/drag-and-drop.md), and the\n   * rows are in flow layout inside a real `ScrollView` that already knows\n   * its own size.\n   *\n   * Kept because upstream's own example app passes it on every\n   * `SortableItem` — a mirror that drops it turns a literal port into an\n   * edit, which is the one thing this module exists to avoid.\n   */\n  containerHeight?: number\n  /** Accepted and ignored, same reason. */\n  isDynamicHeight?: boolean\n  scheduleHeightUpdate?: (id: string, height: number) => void\n}\n\nexport interface SortableCallbacks {\n  onMove?: (id: string, from: number, to: number) => void\n  onDragStart?: (id: string, position: number) => void\n  onDrop?: (\n    id: string,\n    position: number,\n    allPositions?: Record<string, number>,\n  ) => void\n  onDragging?: (\n    id: string,\n    overItemId: string | null,\n    yPosition: number,\n  ) => void\n}\n\nexport interface UseSortableOptions<TData = unknown>\n  extends SortableCallbacks, SortableItemPlumbing {\n  id: string\n  data?: TData\n}\n\nexport interface UseSortableReturn {\n  /** Upstream returns a Reanimated style here. This platform reorders by\n   *  re-rendering, so the row needs no transform — the field stays for\n   *  spread compatibility. */\n  animatedStyle: StyleProp\n  isMoving: boolean\n  hasHandle: boolean\n  registerHandle: (registered: boolean) => void\n  /** Everything the row's view must contain: the drop target always, and the\n   *  drag source unless a handle has claimed it. */\n  children: ReactNode\n  /** The drag source on its own, for a caller placing its own handle. */\n  dragControllers: ReactNode\n}\n\nexport interface SortableItemProps<TData = unknown>\n  extends Partial<SortableItemPlumbing>, SortableCallbacks {\n  id: string\n  data?: TData\n  children: ReactNode\n  style?: StyleProp\n  /** Accepted for spread compatibility; upstream's own transform style. */\n  animatedStyle?: StyleProp\n  direction?: SortableDirection\n  testID?: string\n}\n\nexport interface SortableRenderItemProps<\n  TData extends SortableData,\n> extends SortableItemPlumbing {\n  item: TData\n  index: number\n  id: string\n  direction?: SortableDirection\n}\n\nexport interface SortableProps<\n  TData extends SortableData,\n> extends SortableCallbacks {\n  data: TData[]\n  renderItem: (props: SortableRenderItemProps<TData>) => ReactNode\n  itemKeyExtractor?: (item: TData, index: number) => string\n  style?: StyleProp\n  contentContainerStyle?: StyleProp\n  testID?: string\n  /** Accepted and ignored — see `SortableItemPlumbing`. */\n  itemHeight?: number | number[] | ((item: TData, index: number) => number)\n  /** Accepted and ignored. */\n  estimatedItemHeight?: number\n  /** Accepted and ignored. */\n  enableDynamicHeights?: boolean\n  /** Accepted and ignored. */\n  useFlatList?: boolean\n  /** Accepted and ignored. */\n  onHeightsMeasured?: (heights: Record<string, number>) => void\n  /** `SortableDirection.Horizontal` is not implemented — see\n   *  docs/research/drag-and-drop.md. Passing it throws, rather than\n   *  silently laying out vertically. */\n  direction?: SortableDirection\n}\n\nexport interface SortableHandleProps {\n  children: ReactNode\n  style?: StyleProp\n  testID?: string\n}\n\nexport interface UseSortableListOptions<TData extends SortableData> {\n  data: TData[]\n  itemKeyExtractor?: (item: TData, index: number) => string\n  itemHeight?: number | number[] | ((item: TData, index: number) => number)\n  enableDynamicHeights?: boolean\n  estimatedItemHeight?: number\n  onHeightsMeasured?: (heights: Record<string, number>) => void\n}\n\nexport interface UseSortableListReturn<TData extends SortableData> {\n  positions: SharedValueLike<Record<string, number>>\n  scrollY: SharedValueLike<number>\n  autoScroll: SharedValueLike<ScrollDirection>\n  itemHeights: SharedValueLike<Record<string, number>>\n  dropProviderRef: RefObject<DropProviderRef | null>\n  handleScroll: () => void\n  handleScrollEnd: () => void\n  contentHeight: number\n  isDynamicHeight: boolean\n  /** The current order, which this hook owns — upstream keeps the same\n   *  contract (\"do NOT update external state in `onMove`\"). */\n  items: TData[]\n  getItemProps: (item: TData, index: number) => SortableItemPlumbing\n}\n"]}

package/dist/gesture-handler-compat/builder.d.ts

@@ -0,0 +1,251 @@
+import type { AnyGestureSpec, ComposedGestureSpec, GestureEventPayload, GestureHitSlop, GestureKind, GestureRef, GestureSpec, GestureStateManagerApi, GestureTouchEvent, OffsetBound, RecognizerConfig } from "./types";
+type TouchHandler = (event: GestureTouchEvent, manager: GestureStateManagerApi) => void;
+/**
+ * Everything upstream's `BaseGesture` has, which is everything the three
+ * implemented kinds share. Not a port of it: it holds no handler tag and no
+ * worklet machinery, because on this platform there is one runtime and a
+ * handler tag identifies a MOUNTED gesture rather than a built one. The
+ * relations it does hold are lists of references and nothing else — the maps
+ * that read them live in ./relations, and the loop that acts on them in
+ * ./orchestrator.
+ *
+ * `onUpdate` and `onChange` are deliberately NOT here. Upstream puts them on
+ * `ContinousBaseGesture`, which `Tap` and `LongPress` do not extend — they are
+ * discrete, they have no travel to report, and offering the methods would
+ * invite a callback that never fires.
+ */
+declare abstract class BaseGestureBuilder implements GestureSpec {
+    abstract readonly kind: GestureKind;
+    readonly config: RecognizerConfig;
+    enabled(value: boolean): this;
+    shouldCancelWhenOutside(value: boolean): this;
+    hitSlop(value: GestureHitSlop): this;
+    manualActivation(value: boolean): this;
+    onBegin(callback: (event: GestureEventPayload) => void): this;
+    onStart(callback: (event: GestureEventPayload) => void): this;
+    onEnd(callback: (event: GestureEventPayload, success: boolean) => void): this;
+    onFinalize(callback: (event: GestureEventPayload, success: boolean) => void): this;
+    onTouchesDown(callback: TouchHandler): this;
+    onTouchesMove(callback: TouchHandler): this;
+    onTouchesUp(callback: TouchHandler): this;
+    onTouchesCancelled(callback: TouchHandler): this;
+    /**
+     * Recorded and not acted on, exactly as upstream does not act on it off its
+     * worklet platforms: gesture callbacks are worklets by default there and
+     * this asks for the JS runtime instead. There is one runtime here, so every
+     * callback already runs where this is asking it to. `@gorhom/bottom-sheet`
+     * sets it twice; making it throw would refuse code that is already correct.
+     *
+     * Recorded rather than discarded so the config still describes what the app
+     * asked for — the orchestrator and any devtools read this object.
+     */
+    runOnJS(value: boolean): this;
+    /**
+     * Platform-specific upstream and inert here, which is upstream's own
+     * treatment of them off their platforms: `averageTouches` is Android-only,
+     * `enableTrackpadTwoFingerGesture` and `cancelsTouchesInView` are iOS-only,
+     * `activeCursor` and `mouseButton` are Web-only. Accepting them keeps
+     * portable source portable; docs/api.md records that they do nothing.
+     */
+    averageTouches(value: boolean): this;
+    enableTrackpadTwoFingerGesture(value: boolean): this;
+    cancelsTouchesInView(value: boolean): this;
+    activeCursor(value: string): this;
+    mouseButton(value: number): this;
+    /** Upstream stores a ref for the relation APIs; harmless to honour early. */
+    withRef(ref: {
+        current: unknown;
+    }): this;
+    withTestId(id: string): this;
+    /** Upstream's flattening hook for composed gestures; a lone gesture is a list of one. */
+    toGestureArray(): BaseGestureBuilder[];
+    simultaneousWithExternalGesture(...gestures: GestureRef[]): this;
+    requireExternalGestureToFail(...gestures: GestureRef[]): this;
+    blocksExternalGesture(...gestures: GestureRef[]): this;
+}
+/** `Gesture.Pan()`, and the only one of the three that reports travel. */
+export declare class PanGestureBuilder extends BaseGestureBuilder {
+    readonly kind: "pan";
+    activeOffsetX(offset: OffsetBound): this;
+    activeOffsetY(offset: OffsetBound): this;
+    failOffsetX(offset: OffsetBound): this;
+    failOffsetY(offset: OffsetBound): this;
+    minDistance(distance: number): this;
+    minVelocity(velocity: number): this;
+    minVelocityX(velocity: number): this;
+    minVelocityY(velocity: number): this;
+    minPointers(count: number): this;
+    maxPointers(count: number): this;
+    activateAfterLongPress(duration: number): this;
+    onUpdate(callback: (event: GestureEventPayload) => void): this;
+    onChange(callback: (event: GestureEventPayload) => void): this;
+}
+/**
+ * `Gesture.Tap()`.
+ *
+ * `shouldCancelWhenOutside` is on by default, set from the constructor exactly
+ * as upstream's `TapGesture` does — a press that wanders off the view is not a
+ * tap on it, and the native `TapGestureHandler` config says the same.
+ */
+export declare class TapGestureBuilder extends BaseGestureBuilder {
+    readonly kind: "tap";
+    constructor();
+    numberOfTaps(count: number): this;
+    maxDuration(duration: number): this;
+    maxDelay(delay: number): this;
+    maxDistance(distance: number): this;
+    maxDeltaX(delta: number): this;
+    maxDeltaY(delta: number): this;
+    minPointers(count: number): this;
+}
+/** `Gesture.LongPress()`, with upstream's default of `shouldCancelWhenOutside`. */
+export declare class LongPressGestureBuilder extends BaseGestureBuilder {
+    readonly kind: "longPress";
+    constructor();
+    minDuration(duration: number): this;
+    maxDistance(distance: number): this;
+    numberOfPointers(count: number): this;
+}
+/**
+ * `Gesture.Native()` — the widget underneath, put into the arbitration.
+ *
+ * `shouldCancelWhenOutside` defaults to true from the constructor, which is
+ * where upstream's `NativeViewGestureHandler.init` sets it rather than its
+ * builder. See ./native for what the recognizer does and, more to the point,
+ * what it deliberately does not do: it never takes the responder, because
+ * taking it is what switches the native scroller off.
+ */
+export declare class NativeGestureBuilder extends BaseGestureBuilder {
+    readonly kind: "native";
+    constructor();
+    shouldActivateOnStart(value: boolean): this;
+    disallowInterruption(value: boolean): this;
+    yieldsToContinuousGestures(value: boolean): this;
+    /**
+     * A native view is CONTINUOUS upstream (`isContinuous = true`), so it
+     * reports travel like `Pan` does and unlike `Tap`. These are here rather
+     * than on the base class for the same reason they are on
+     * `PanGestureBuilder`: upstream puts them on `ContinousBaseGesture`.
+     */
+    onUpdate(callback: (event: GestureEventPayload) => void): this;
+    onChange(callback: (event: GestureEventPayload) => void): this;
+}
+/**
+ * `Gesture.Pinch()` and `Gesture.Rotation()`, which have no configuration of
+ * their own at all — verified against 3.1.0, where `PinchGesture` and
+ * `RotationGesture` add zero builder methods over `ContinousBaseGesture`, and
+ * where v3's `PinchGestureNativeProperties` is literally
+ * `Record<string, never>`. Both are CONTINUOUS, so `onUpdate`/`onChange` are
+ * here for the same reason they are on `PanGestureBuilder`.
+ *
+ * `shouldCancelWhenOutside` is off, set from the constructor because upstream
+ * sets it from `PinchGestureHandler.init`/`RotationGestureHandler.init` — a
+ * pinch whose focal point wanders off the view keeps running, unlike a tap.
+ *
+ * What they do NOT have is a pointer: see ./touchpad. Their numbers come from
+ * `GtkGestureZoom`/`GtkGestureRotate`, and everything else about them — the
+ * states, the callbacks, the arbitration — is the machine every other kind
+ * runs on.
+ */
+export declare class PinchGestureBuilder extends BaseGestureBuilder {
+    readonly kind: "pinch";
+    constructor();
+    onUpdate(callback: (event: GestureEventPayload) => void): this;
+    onChange(callback: (event: GestureEventPayload) => void): this;
+}
+/** `Gesture.Rotation()`. Same shape as `Pinch`, same reasons. */
+export declare class RotationGestureBuilder extends BaseGestureBuilder {
+    readonly kind: "rotation";
+    constructor();
+    onUpdate(callback: (event: GestureEventPayload) => void): this;
+    onChange(callback: (event: GestureEventPayload) => void): this;
+}
+/**
+ * `Gesture.Fling()` — a directional swipe, and the one DISCRETE gesture with a
+ * velocity criterion.
+ *
+ * No `onUpdate`/`onChange`, and that is upstream's shape rather than an
+ * omission: `FlingGesture` extends `BaseGesture` and not
+ * `ContinousBaseGesture`, because a fling activates and ends in the same
+ * breath (see ./fling) and there is never an update to report between them.
+ * Offering the methods would invite a callback that cannot fire.
+ */
+export declare class FlingGestureBuilder extends BaseGestureBuilder {
+    readonly kind: "fling";
+    /** A BITMASK of `Directions`; several are one value, OR'd together. */
+    direction(direction: number): this;
+    numberOfPointers(count: number): this;
+}
+/**
+ * `Gesture.Manual()` — no configuration at all, because there is nothing to
+ * configure: the app drives the state machine through the manager handed to
+ * the `onTouches*` callbacks.
+ *
+ * Verified against 3.1.0, where `ManualGesture` adds zero builder methods over
+ * `ContinousBaseGesture` and v3's `ManualGestureProperties` is
+ * `Record<string, never>`. Continuous, so `onUpdate`/`onChange` are here.
+ */
+export declare class ManualGestureBuilder extends BaseGestureBuilder {
+    readonly kind: "manual";
+    onUpdate(callback: (event: GestureEventPayload) => void): this;
+    onChange(callback: (event: GestureEventPayload) => void): this;
+}
+/**
+ * `Gesture.Hover()` — the pointer being over the view, with no button down.
+ *
+ * `effect()` is upstream's one knob and it is iOS-only there; it is recorded
+ * and inert here, exactly as it is inert in upstream's own web handler, which
+ * never branches on it either. Continuous, so it reports travel.
+ */
+export declare class HoverGestureBuilder extends BaseGestureBuilder {
+    readonly kind: "hover";
+    effect(effect: number): this;
+    onUpdate(callback: (event: GestureEventPayload) => void): this;
+    onChange(callback: (event: GestureEventPayload) => void): this;
+}
+/**
+ * `Gesture.ForceTouch()` — pressure, and the one recognizer in this module
+ * whose input the test rig cannot fully produce. See ./force-touch, which
+ * says so at length, and docs/api.md, which says it where an app will read it.
+ *
+ * Continuous, matching upstream's `ContinousBaseGesture`.
+ */
+export declare class ForceTouchGestureBuilder extends BaseGestureBuilder {
+    readonly kind: "forceTouch";
+    minForce(force: number): this;
+    maxForce(force: number): this;
+    /** Haptics. Recorded and inert: there is no haptic device on this platform. */
+    feedbackOnActivation(value: boolean): this;
+    onUpdate(callback: (event: GestureEventPayload) => void): this;
+    onChange(callback: (event: GestureEventPayload) => void): this;
+}
+/**
+ * `Gesture`, the namespace of statics — all ten of them, and the three
+ * composers.
+ *
+ * Nothing here throws any more. The four that used to (`Fling`, `Hover`,
+ * `Manual`, `ForceTouch`) are the last of upstream's surface and the reasons
+ * they were refused have been re-examined one at a time rather than inherited:
+ * `Fling` and `Manual` were always reachable and merely unwritten, `Hover` was
+ * refused on a judgement about the rig that was simply wrong (a mouse hovers,
+ * and the virtual pointer moves a mouse), and `ForceTouch` is the one that
+ * needs hardware — it ships with upstream's documented semantics and an
+ * explicit note about what is unverified, rather than a refusal that says
+ * nothing.
+ */
+export declare const Gesture: {
+    Pan: () => PanGestureBuilder;
+    Tap: () => TapGestureBuilder;
+    LongPress: () => LongPressGestureBuilder;
+    Native: () => NativeGestureBuilder;
+    Race: (...gestures: AnyGestureSpec[]) => ComposedGestureSpec;
+    Simultaneous: (...gestures: AnyGestureSpec[]) => ComposedGestureSpec;
+    Exclusive: (...gestures: AnyGestureSpec[]) => ComposedGestureSpec;
+    Pinch: () => PinchGestureBuilder;
+    Rotation: () => RotationGestureBuilder;
+    Fling: () => FlingGestureBuilder;
+    Hover: () => HoverGestureBuilder;
+    Manual: () => ManualGestureBuilder;
+    ForceTouch: () => ForceTouchGestureBuilder;
+};
+export {};