import { ReactNode } from 'react';

type ExtractArgs<T extends object> = T[keyof T] extends (...args: infer A) => any ? A : any[];
type EventState<T extends object, Args extends unknown[] = ExtractArgs<T>> = T & {
    (key?: keyof T, fun?: T[keyof T]): EventState<T, Args>;
    (target?: Partial<T>): EventState<T, Args>;
};

type Vec2 = [x: number, y: number];

type PinchDevice = 'mouse' | 'pointer' | 'touch' | 'wheel' | 'gesture';
interface PinchState<El extends Element = Element> {
    device: PinchDevice;
    active: boolean;
    _active: boolean;
    value: Vec2;
    _value: Vec2;
    delta: Vec2;
    offset: Vec2;
    movement: Vec2;
    initial: Vec2;
    origin: Vec2;
    _touchIds: number[];
    _pointerEvents: Map<number, PointerEvent>;
    scale: number;
    turns: number;
    target: El;
    event: Event | null;
    memo: Record<string, unknown>;
    timeout: number;
    clearTimeout: () => void;
    isPinchStart: boolean;
    isPinching: boolean;
    isPinchEnd: boolean;
    pinch: (self: PinchState<El>) => void;
    pinchStart: (e: Event) => void;
    pinching: (e: Event) => void;
    pinchEnd: (e: Event) => void;
    mount: (target: El) => void;
    clean: () => void;
    ref: (el: El | null) => void;
}
type PinchArg<El extends Element = Element> = Partial<PinchState<El>> | PinchState<El>['pinch'];

declare const usePinch: <El extends Element = Element>(arg?: PinchArg) => EventState<PinchState<El>>;

interface PinchProps<El extends Element = Element> extends Partial<PinchState<El>> {
    children: (state: PinchState<El>) => ReactNode;
}
declare const Pinch: (props: PinchProps) => ReactNode;

export { Pinch, type PinchProps, usePinch as default, usePinch };