import { Observable, ReplaySubject } from 'rxjs';
export declare class PointerEventProvider {
    /**
     * HTML canvas element within the HTML5 document to register event listeners to.
     */
    protected _element: HTMLCanvasElement;
    /**
     * Time frame for events to be buffered (windowTime in rxjs per ReplaySubject).
     */
    protected _timeframe: number | undefined;
    protected _enterListener: {
        (event: PointerEvent): void;
    };
    protected _enterSubject: ReplaySubject<PointerEvent>;
    protected _leaveListener: {
        (event: PointerEvent): void;
    };
    protected _leaveSubject: ReplaySubject<PointerEvent>;
    protected _cancelListener: {
        (event: PointerEvent): void;
    };
    protected _cancelSubject: ReplaySubject<PointerEvent>;
    protected _downListener: {
        (event: PointerEvent): void;
    };
    protected _downSubject: ReplaySubject<PointerEvent>;
    protected _upListener: {
        (event: PointerEvent): void;
    };
    protected _upSubject: ReplaySubject<PointerEvent>;
    protected _moveListener: {
        (event: PointerEvent): void;
    };
    protected _moveSubject: ReplaySubject<PointerEvent>;
    /** @see {@link pointerLock} */
    protected _pointerLockRequestPending: boolean;
    /**
     * This mask saves for which types of events, event.preventDefault should be called. This is useful to disallow
     * some kinds of standard events like scrolling or clicking on links.
     */
    protected _preventDefaultMask: PointerEventProvider.Type;
    constructor(element: HTMLCanvasElement, timeframe?: number);
    /**
     * The pointer lock API requires a little workaround in order to avoid something like '... not called from inside a
     * short running user-generated event handler'. A click event listener is registered and whenever a pointer lock is
     * requested, e.g., from an event handler (which in turn exposes this interface to, e.g., a navigation), the next
     * click will result in a probably more successful pointer lock.
     */
    protected processPointerLockRequests(): void;
    /**
     * Checks whether or not to prevent the default handling of the given event. This depends on the internal
     * `preventDefaultMask` which can be modified using `preventDefault` function @see{@link preventDefault}.
     * @param type - Internal event type of the incoming event.
     * @param event - Actual event to prevent default handling on (if masked).
     */
    protected preventDefaultOnEvent(type: PointerEventProvider.Type, event: PointerEvent): void;
    /**
     * Prevent default event handling on specific event types (using preventDefault on the event).
     * @param types - Event types to prevent default handling on.
     */
    preventDefault(...types: PointerEventProvider.Type[]): void;
    /**
     * Allow default event handling on specific event types (not calling preventDefault on the event).
     * @param types - Event types to allow default handling on.
     */
    allowDefault(...types: PointerEventProvider.Type[]): void;
    observable(type: PointerEventProvider.Type): Observable<PointerEvent> | undefined;
    /**
     * Enable/disable pointer lock on click. If true, the next click on this event provider's canvas will invoke a
     * pointer lock request on the canvas element.
     */
    set pointerLock(lock: boolean);
    get pointerLock(): boolean;
    get enter$(): Observable<PointerEvent>;
    get leave$(): Observable<PointerEvent>;
    get down$(): Observable<PointerEvent>;
    get up$(): Observable<PointerEvent>;
    get move$(): Observable<PointerEvent>;
    get cancel$(): Observable<PointerEvent>;
}
export declare namespace PointerEventProvider {
    enum Type {
        Enter = 1,
        Leave = 2,
        Move = 4,
        Down = 8,
        Up = 16,
        Cancel = 32
    }
}