import { vec2 } from 'gl-matrix';
import { Subscription } from 'rxjs';
import { EyeGazeEvent } from './eyegazeevent';
import { EyeGazeEventProvider } from './eyegazeeventprovider';
import { MouseEventProvider } from './mouseeventprovider';
import { PointerEventProvider } from './pointereventprovider';
import { Invalidate } from './renderer';
import { TouchEventProvider } from './toucheventprovider';
import { KeyboardEventProvider, KeyboardEventType } from './keyboardeventprovider';
export interface EventProvider {
    pointerEventProvider: PointerEventProvider;
    mouseEventProvider: MouseEventProvider;
    eyeGazeEventProvider?: EyeGazeEventProvider;
    keyboardEventProvider?: KeyboardEventProvider;
}
/**
 * Callback for handling mouse events, given the latest mouse events (since last update) as well as the previous.
 */
export interface MouseEventHandler {
    (latests: Array<MouseEvent>, previous: Array<MouseEvent>): void;
}
/**
 * Callback for handling touch events, given the latest touch events (since last update) as well as the previous.
 */
export interface TouchEventHandler {
    (latests: Array<TouchEvent>, previous: Array<TouchEvent>): void;
}
/**
 * Callback for handling pointer events, given the latest touch events (since last update) as well as the previous.
 */
export interface PointerEventHandler {
    (latests: Array<PointerEvent>, previous: Array<PointerEvent>): void;
}
/**
 * Callback for handling eye gaze events, given the latest eye gaze events (since last update) as well as the previous.
 */
export interface EyeGazeEventHandler {
    (latests: Array<EyeGazeEvent>, previous: Array<EyeGazeEvent>): void;
}
/**
 * Callback for handling keyboard events, given the latest keyboard events (since last update) as well as the previous.
 */
export interface KeyboardEventHandler {
    (latests: Array<KeyboardEvent>, previous: Array<KeyboardEvent>): void;
}
/**
 * ... Provider and event handler are explicitly separated in order to reduce the number of observables (reuse of event
 * provider for multiple handler).
 */
export declare class EventHandler {
    /**
     * The event handler's invalidation callback. This should usually be setup by the owning renderer and invoke the
     * same callback the renderer has been given by the canvas. This invalidation is required, when continuous
     * rendering is not present, events might cause need for new rendering requests.
     */
    protected _invalidate: Invalidate | undefined;
    protected _subscriptions: Subscription[];
    /**
     * Assigned key event provider. This is usually created and owned by the canvas.
     */
    /**
     * Assigned mouse event provider. This is usually created and owned by the canvas.
     */
    protected _mouseEventProvider: MouseEventProvider | undefined;
    /**
     * Assigned touch event provider. This is usually created and owned by the canvas.
     */
    protected _touchEventProvider: TouchEventProvider | undefined;
    /**
     * Assigned pointer event provider. This is usually created and owned by the canvas.
     */
    protected _pointerEventProvider: PointerEventProvider | undefined;
    /**
     * Assigned eye gaze event provider. This is usually created and owned by the eye gaze data stream.
     */
    protected _eyeGazeEventProvider: EyeGazeEventProvider | undefined;
    /**
     * Assigned keyboard event provider. This is usually created and owned by the canvas.
     */
    protected _keyboardEventProvider: KeyboardEventProvider | undefined;
    protected _latestMouseEventsByType: Map<MouseEventProvider.Type, MouseEvent[]>;
    protected _previousMouseEventsByType: Map<MouseEventProvider.Type, MouseEvent[]>;
    protected _mouseEventHandlerByType: Map<MouseEventProvider.Type, MouseEventHandler[]>;
    protected _latestTouchEventsByType: Map<TouchEventProvider.Type, TouchEvent[]>;
    protected _previousTouchEventsByType: Map<TouchEventProvider.Type, TouchEvent[]>;
    protected _touchEventHandlerByType: Map<TouchEventProvider.Type, TouchEventHandler[]>;
    protected _latestPointerEventsByType: Map<PointerEventProvider.Type, PointerEvent[]>;
    protected _previousPointerEventsByType: Map<PointerEventProvider.Type, PointerEvent[]>;
    protected _pointerEventHandlerByType: Map<PointerEventProvider.Type, PointerEventHandler[]>;
    protected _latestEyeGazeEventsByType: Map<EyeGazeEventProvider.Type, EyeGazeEvent[]>;
    protected _previousEyeGazeEventsByType: Map<EyeGazeEventProvider.Type, EyeGazeEvent[]>;
    protected _eyeGazeEventHandlerByType: Map<EyeGazeEventProvider.Type, EyeGazeEventHandler[]>;
    protected _latestKeyboardEventsByType: Map<KeyboardEventType, KeyboardEvent[]>;
    protected _previousKeyboardEventsByType: Map<KeyboardEventType, KeyboardEvent[]>;
    protected _keyboardEventHandlerByType: Map<KeyboardEventType, KeyboardEventHandler[]>;
    constructor(invalidate: Invalidate | undefined, eventProvider: EventProvider);
    /** @callback Invalidate
     * A callback intended to be invoked whenever the specialized event handler itself is invalid. By default only
     * optional updates (renderer decides whether or not to continue redraw) are triggered.
     */
    protected invalidate(force?: boolean): void;
    /**
     * Utility for registering an additional mouse event handler for updates on mouse events of the given type. The
     * handler is to be called on update if at least a single mouse event of the given type has occurred since last
     * update.
     * @param type - Mouse event type the handler is to be associated with.
     * @param handler - Handler to be called on update.
     */
    protected pushMouseEventHandler(type: MouseEventProvider.Type, handler: MouseEventHandler): void;
    protected invokeMouseEventHandler(type: MouseEventProvider.Type): void;
    /**
     * Utility for registering an additional touch event handler for updates on touch events of the given type. The
     * handler is to be called on update iff at least a single touch event of the given type has occurred since last
     * update.
     * @param type - Touch event type the handler is to be associated with.
     * @param handler - Handler to be called on update.
     */
    protected pushTouchEventHandler(type: TouchEventProvider.Type, handler: TouchEventHandler): void;
    protected invokeTouchEventHandler(type: TouchEventProvider.Type): void;
    /**
     * Utility for registering an additional pointer event handler for updates on pointer events of the given type. The
     * handler is to be called on update iff at least a single touch event of the given type has occurred since last
     * update.
     * @param type - Pointer event type the handler is to be associated with.
     * @param handler - Handler to be called on update.
     */
    protected pushPointerEventHandler(type: PointerEventProvider.Type, handler: PointerEventHandler): void;
    protected invokePointerEventHandler(type: PointerEventProvider.Type): void;
    /**
     * Utility for registering an additional touch event handler for updates on touch events of the given type. The
     * handler is to be called on update iff at least a single touch event of the given type has occurred since last
     * update.
     * @param type - Touch event type the handler is to be associated with.
     * @param handler - Handler to be called on update.
     */
    protected pushEyeGazeEventHandler(type: EyeGazeEventProvider.Type, handler: EyeGazeEventHandler): void;
    protected invokeEyeGazeEventHandler(type: EyeGazeEventProvider.Type): void;
    /**
     * Utility for registering an additional keyboard event handler for updates on keyboard events of the given type. The
     * handler is to be called on update if at least a single keyboard event of the given type has occurred since last
     * update.
     * @param type - Keyboard event type the handler is to be associated with.
     * @param handler - Handler to be called on update.
     */
    protected pushKeyboardEventHandler(type: KeyboardEventType, handler: KeyboardEventHandler): void;
    protected invokeKeyboardEventHandler(type: KeyboardEventType): void;
    /**
     * Disposes all registered handlers of all event types.
     */
    dispose(): void;
    /**
     * Triggers (by means of a helper function) invocation of all registered handler of all event types.
     */
    update(): void;
    /**
     * Normalize mouse and touch event coordinates for various browsers.
     * @param event - Mouse, wheel, or touch event.
     * @param normalize - Whether or not to compute normalized coordinates (offsets).
     * @returns - Array of normalized x and y offsets (in case of multiple touches).
     */
    offsets(event: MouseEvent | WheelEvent | TouchEvent, normalize?: boolean): Array<vec2>;
    /**
     * Register a click event handler that is to be called on update iff at least a single click event has
     * occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushClickHandler(handler: MouseEventHandler): void;
    /**
     * Register an mouse enter event handler that is to be called on update iff at least a single mouse enter event has
     * occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushMouseEnterHandler(handler: MouseEventHandler): void;
    /**
     * Register an mouse leave event handler that is to be called on update iff at least a single mouse leave event has
     * occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushMouseLeaveHandler(handler: MouseEventHandler): void;
    /**
     * Register an mouse down event handler that is to be called on update iff at least a single mouse down event has
     * occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushMouseDownHandler(handler: MouseEventHandler): void;
    /**
     * Register an mouse up event handler that is to be called on update iff at least a single mouse up event has
     * occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushMouseUpHandler(handler: MouseEventHandler): void;
    /**
     * Register an mouse move event handler that is to be called on update iff at least a single mouse move event has
     * occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushMouseMoveHandler(handler: MouseEventHandler): void;
    /**
     * Register an mouse wheel event handler that is to be called on update iff at least a single mouse wheel event has
     * occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushMouseWheelHandler(handler: MouseEventHandler): void;
    /**
     * Register a touch start event handler that is to be called on update iff at least a single touch start event has
     * occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushTouchStartHandler(handler: TouchEventHandler): void;
    /**
     * Register a touch end event handler that is to be called on update iff at least a single touch end event has
     * occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushTouchEndHandler(handler: TouchEventHandler): void;
    /**
     * Register a touch move event handler that is to be called on update iff at least a single touch move event has
     * occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushTouchMoveHandler(handler: TouchEventHandler): void;
    /**
     * Register a touch cancel event handler that is to be called on update iff at least a single touch cancel event has
     * occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushTouchCancelHandler(handler: TouchEventHandler): void;
    /**
     * Register a pointer up event handler that is to be called on update iff at least a single touch cancel event has
     * occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushPointerUpHandler(handler: PointerEventHandler): void;
    /**
     * Register a pointer down event handler that is to be called on update iff at least a single touch cancel event has
     * occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushPointerDownHandler(handler: PointerEventHandler): void;
    /**
     * Register a pointer enter event handler that is to be called on update iff at least a single touch cancel event
     * has occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushPointerEnterHandler(handler: PointerEventHandler): void;
    /**
     * Register a pointer leave event handler that is to be called on update iff at least a single touch cancel event
     * has occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushPointerLeaveHandler(handler: PointerEventHandler): void;
    /**
     * Register a pointer move event handler that is to be called on update iff at least a single touch cancel event has
     * occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushPointerMoveHandler(handler: PointerEventHandler): void;
    /**
     * Register a pointer cancel event handler that is to be called on update iff at least a single touch cancel event
     * has occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushPointerCancelHandler(handler: PointerEventHandler): void;
    /**
     * Register a eye gaze data event handler that is to be called on update if at least
     * a single eye gaze data event has occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushEyeGazeDataHandler(handler: EyeGazeEventHandler): void;
    /**
     * Register a eye gaze server message event handler that is to be called on update if at least
     * a single eye gaze server message event has occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushEyeGazeServerMessageHandler(handler: EyeGazeEventHandler): void;
    /**
     * Register a eye gaze connection status event handler that is to be called on update if at least
     * a single eye gaze connection status event has occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushEyeGazeConnectionStatusHandler(handler: EyeGazeEventHandler): void;
    /**
     * Register a eye gaze binary message parsing error event handler that is to be called on update if at least
     * a single eye gaze binary message parsing error event has occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushEyeGazeBinaryMessageParsingErrorHandler(handler: EyeGazeEventHandler): void;
    /**
         * Register a key down event handler that is to be called on update if at least a single key down event has
         * occurred since last update.
         * @param handler - Handler to be called on update.
         */
    pushKeyDownHandler(handler: KeyboardEventHandler): void;
    /**
     * Register a key press event handler that is to be called on update if at least a single key press event has
     * occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushKeyPressHandler(handler: KeyboardEventHandler): void;
    /**
     * Register a key up event handler that is to be called on update if at least a single key up event has
     * occurred since last update.
     * @param handler - Handler to be called on update.
     */
    pushKeyUpHandler(handler: KeyboardEventHandler): void;
    /**
     * Forward pointer lock request to the mouse event provider (if one exists).
     */
    requestPointerLock(): void;
    /**
     * Forward pointer lock release request to the mouse event provider (if one exists).
     */
    exitPointerLock(): void;
}