export interface GestureStart {
    x: number;
    y: number;
    t: number;
}
export interface GestureMove {
    x: number;
    y: number;
    /** Displacement from the start point. */
    dx: number;
    dy: number;
}
export interface GestureEnd {
    x: number;
    y: number;
    dx: number;
    dy: number;
    /** Elapsed time from start to end (ms). */
    dt: number;
    /** Velocity of the final move segment (px/ms). */
    vx: number;
    vy: number;
    /** A fast flick: final speed exceeded the swipe threshold and the gesture was not canceled. */
    swipe: boolean;
    /** The pointer was canceled (e.g. pointercancel) rather than lifted. */
    canceled: boolean;
}
export interface PointerHandlers {
    onStart?: (g: GestureStart) => void;
    onMove?: (g: GestureMove) => void;
    onEnd?: (g: GestureEnd) => void;
}
/**
 * Recognizes a single-pointer drag from raw pointer samples and reports normalized
 * gestures. DOM-agnostic on purpose: `bindPointerInput` maps real PointerEvents onto
 * it, but the kinematics stay pure and unit-testable. Extra pointers are ignored
 * (multi-touch pinch is a separate recognizer).
 */
export declare class PointerRecognizer {
    #private;
    constructor(handlers?: PointerHandlers);
    get active(): boolean;
    down(id: number, x: number, y: number, t: number): void;
    move(id: number, x: number, y: number, t: number): void;
    up(id: number, x: number, y: number, t: number): void;
    cancel(id: number, x: number, y: number, t: number): void;
}
/**
 * Wire real PointerEvents from `target` into a recognizer. Returns an unbind
 * function that removes every listener. Coordinates are passed through as
 * client-space; mapping to page-local space is the engine's job.
 */
export declare function bindPointerInput(target: EventTarget, recognizer: PointerRecognizer): () => void;
/**
 * Wire PointerEvents from `target` into a drag recognizer and/or a pinch
 * recognizer at once, so a single pointer stream feeds both. Returns an unbind.
 */
export declare function bindGestures(target: EventTarget, recognizers: {
    pointer?: PointerRecognizer;
    pinch?: PinchRecognizer;
}): () => void;
export interface PinchStart {
    centerX: number;
    centerY: number;
    /** Distance between the two pointers at pinch start. */
    distance: number;
}
export interface PinchMove {
    centerX: number;
    centerY: number;
    /** Current distance / start distance. */
    scale: number;
}
export interface PinchHandlers {
    onPinchStart?: (g: PinchStart) => void;
    onPinchMove?: (g: PinchMove) => void;
    onPinchEnd?: () => void;
}
/**
 * Recognizes a two-pointer pinch and reports zoom scale (relative to the start
 * distance) and the live center point. No timestamps: pinch drives zoom, not a
 * flick. A third pointer is ignored; lifting either tracked pointer ends the pinch.
 * Coordinating this with the drag recognizer (a second finger should suspend a
 * single-finger drag) is the engine's job.
 */
export declare class PinchRecognizer {
    #private;
    constructor(handlers?: PinchHandlers);
    get pinching(): boolean;
    down(id: number, x: number, y: number): void;
    move(id: number, x: number, y: number): void;
    up(id: number): void;
    cancel(id: number): void;
}