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 DragDevice = 'mouse' | 'touch' | 'pointer';
interface DragState<El extends Element = Element> {
    _active: boolean;
    active: boolean;
    device: DragDevice;
    _value: Vec2;
    value: Vec2;
    delta: Vec2;
    offset: Vec2;
    movement: Vec2;
    target: El;
    event: Event;
    memo: any;
    isDragStart: boolean;
    isDragging: boolean;
    isDragEnd: boolean;
    drag(self: DragState<El>): void;
    dragStart(e: Event): void;
    dragging(e: Event): void;
    dragEnd(e: Event): void;
    mount(target: El): void;
    clean(el: null): void;
    ref(traget: El | null): void;
}
type DragArg<El extends Element> = Partial<DragState<El>> | DragState<El>['drag'];

declare const EVENT_FOR_DRAG: {
    touch: {
        start: string;
        move: string;
        end: string;
        up: string;
    };
    pointer: {
        start: string;
        move: string;
        end: string;
        up: string;
    };
    mouse: {
        start: string;
        move: string;
        end: string;
        up: string;
    };
};
declare const dragEvent: <El extends Element = Element>(state?: Partial<DragState<El>>) => EventState<DragState<El>>;

interface HoverState<El extends Element = Element> {
    _active: boolean;
    active: boolean;
    device: 'mouse' | 'pointer' | 'touch';
    _value: Vec2;
    value: Vec2;
    delta: Vec2;
    offset: Vec2;
    movement: Vec2;
    event: Event;
    target: El;
    isHoverStart: boolean;
    isHovering: boolean;
    isHoverEnd: boolean;
    hover: (self: HoverState) => void;
    hoverStart(e: Event): void;
    hovering(e: Event): void;
    hoverEnd(e: Event): void;
    mount(target: El): void;
    clean(target?: El): void;
    ref(target: El | null): void;
}
type HoverArg<El extends Element = Element> = Partial<HoverState<El>> | HoverState<El>['hover'];

declare const EVENT_FOR_HOVER: {
    touch: {
        start: string;
        move: string;
        end: string;
        up: string;
    };
    pointer: {
        start: string;
        move: string;
        end: string;
        up: string;
    };
    mouse: {
        start: string;
        move: string;
        end: string;
        up: string;
    };
};
declare const hoverEvent: <El extends Element = Element>(state?: Partial<HoverState<El>>) => EventState<HoverState<El>>;

interface KeyState<El extends Element = Element> {
    target: El | Window;
    pressedKey: string;
    code: string;
    event: KeyboardEvent;
    key(e: KeyState): void;
    keydown(e: KeyboardEvent): void;
    mount(el: El): void;
    clean(el: null): void;
    ref(el: Element | null): void;
}
type KeyArg<El extends Element = Element> = Partial<KeyState<El>> | KeyState<El>['key'];

declare const keyEvent: <El extends Element = Element>(state?: Partial<KeyState<El>>) => EventState<KeyState<El>>;

interface ResizeState<El extends Element = Element> {
    observer: ResizeObserver | null;
    listener(): void;
    mount(el: El): void;
    clean(el: null): void;
    resize(self: ResizeState<El>): void;
    ref(target: El): void;
}
type ResizeArg<El extends Element = Element> = Partial<ResizeState<El>> | ResizeState<El>['resize'];

declare const resizeEvent: <El extends Element = Element>(state: ResizeState) => EventState<ResizeState<El>>;

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 pinchDevice: (touch?: boolean) => "touch" | "pointer" | "wheel" | "gesture";
interface DistanceAngle {
    distance: number;
    angle: number;
    origin: Vec2;
}

declare const EVENT_FOR_PINCH: {
    touch: {
        start: string;
        move: string;
        end: string;
        cancel: string;
    };
    pointer: {
        start: string;
        move: string;
        end: string;
        cancel: string;
    };
    gesture: {
        start: string;
        change: string;
        end: string;
    };
};
declare const pinchEvent: <El extends Element = Element>(config?: Partial<PinchState<El>>) => EventState<PinchState<El>>;

interface ScrollState<El extends Element = Element> {
    _active: boolean;
    active: boolean;
    _value: Vec2;
    value: Vec2;
    delta: Vec2;
    offset: Vec2;
    movement: Vec2;
    target: El;
    event: Event;
    memo: any;
    isScrollStart: boolean;
    isScrolling: boolean;
    isScrollEnd: boolean;
    timeout: number;
    clearTimeout(): void;
    scroll(self: ScrollState<El>): void;
    scrollStart(e: Event): void;
    scrolling(e: Event): void;
    scrollEnd(e: Event): void;
    mount(target: El): void;
    clean(target: null): void;
    ref(traget: El | null): void;
    tick?: () => void;
}
type ScrollConfig<El extends Element = Element> = Partial<ScrollState<El>> | ScrollState<El>['scroll'];

declare const scrollEvent: <El extends Element = Element>(config?: ScrollState) => EventState<ScrollState<El>>;

interface WheelState<El extends Element = Element> {
    _active: boolean;
    active: boolean;
    _value: Vec2;
    value: Vec2;
    delta: Vec2;
    offset: Vec2;
    movement: Vec2;
    target: El;
    event: Event;
    timeout: number;
    clearTimeout(): void;
    memo: any;
    isWheelStart: boolean;
    isWheeling: boolean;
    isWheelEnd: boolean;
    wheel(self: WheelState<El>): void;
    wheelStart(e: Event): void;
    wheeling(e: Event): void;
    wheelEnd(e: Event): void;
    mount(target: El): void;
    clean(target: null): void;
    ref(traget: El | null): void;
    tick?: () => void;
}
type WheelConfig<El extends Element = Element> = Partial<WheelState<El>> | WheelState<El>['wheel'];

declare const wheelEvent: <El extends Element = Element>(config?: WheelState) => EventState<WheelState<El>>;

export { type DistanceAngle, type DragArg, type DragDevice, type DragState, EVENT_FOR_DRAG, EVENT_FOR_HOVER, EVENT_FOR_PINCH, type HoverArg, type HoverState, type KeyArg, type KeyState, type PinchArg, type PinchDevice, type PinchState, type ResizeArg, type ResizeState, type ScrollConfig, type ScrollState, type WheelConfig, type WheelState, dragEvent, hoverEvent, keyEvent, pinchDevice, pinchEvent, resizeEvent, scrollEvent, wheelEvent };