declare module "point" {
    export class Point {
        x: number;
        y: number;
        constructor(x: number, y: number);
        distanceTo(p: Point): number;
        deltaAngleTo(p: Point): number;
        clone(): Point;
    }
}
declare module "utils" {
    import { Point } from "point";
    export const GESTURE_STRATEGY_FLAG: {
        KEEP: number;
        REMOVE_IF_POINTERS_GT: number;
    };
    export const RETURN_FLAG: {
        map(result: number | boolean): number;
        IDLE: number;
        START_EMITTED: number;
        REMOVE: number;
        REMOVE_OTHERS: number;
        REMOVE_AND_CONTINUE: number;
        COMPOSE: number;
    };
    export interface Supports {
        msPointerEnabled: boolean;
        pointerEnabled: boolean;
        touchEnabled: boolean;
    }
    export const SUPPORTS: Supports;
    export function isMouse(evt: any, supports?: Supports): boolean;
    export function isValidMouseButton({button, which}: {
        button?: number | undefined;
        which?: number | undefined;
    }, allowedBtn: number[] | number): boolean;
    export function matchesSelector(element: any, selector: string): any;
    export interface PointerData {
        page: Point;
        client: Point;
    }
    export class PointerDataMap extends Map<number, PointerData> {
    }
    export interface Pointers {
        all: PointerDataMap;
        changed: PointerDataMap;
    }
    export class Options {
        pointers: number;
        which: number;
        prio: number;
        strategy: number;
    }
    export class Data {
        pointers: PointerData[];
    }
    export function ensureProperties<T1, T2 extends T1>(target: T2, source: T2): T1 & T2;
}
declare module "listener" {
    import { Options, Data } from "utils";
    export class ListenerArgs<D> {
        evt: Event;
        data: D;
        target: Element;
    }
    export class DefaultListenerArgs extends ListenerArgs<Data> {
    }
    export class Listener<O extends Options, D extends Data> {
        options: O;
        selector: string;
        listener: Listener<O, D>;
        constructor(options: O, listener?: Listener<O, D>);
        down(args: ListenerArgs<D>): number;
        start(args: ListenerArgs<D>): number;
        update(args: ListenerArgs<D>): number;
        end(args: ListenerArgs<D>): number;
        cancel(): number;
        stop(): void;
    }
    export class DefaultListener extends Listener<Options, Data> {
    }
}
declare module "gesture" {
    import { Data, PointerData } from "utils";
    import { DefaultListener, ListenerArgs } from "listener";
    export class Gesture<D extends Data, L extends DefaultListener> {
        listener: L;
        data: D;
        target: Element;
        __POINTERIDS__: number[];
        __REMOVED_POINTERS__: PointerData[];
        startEmitted: boolean;
        args: ListenerArgs<D>;
        constructor(listener: L, data: D, target: Element);
        bind(target: Element, registerListener: <T extends typeof Gesture>(Type: T, element: Element, listener: Partial<DefaultListener>) => () => void, remove: () => void, evt: Event): void;
        unbind(): number;
        start(args: ListenerArgs<D>): number;
        update(args: ListenerArgs<D>): number;
        end(args: ListenerArgs<D>): number;
        cancel(): number;
        stop(): void;
    }
    export class DefaultGesture extends Gesture<Data, DefaultListener> {
    }
}
declare module "registry" {
    import { Gesture } from "gesture";
    import { Listener, DefaultListener } from "listener";
    import { Options, Data } from "utils";
    export class Registry {
        private gestures;
        register<G extends typeof Gesture, O extends typeof Options, L extends typeof Listener, D extends typeof Data>(Gesture: G, GestureOptions?: O, GestureListener?: L, GestureData?: D): void;
        getTypes(): typeof Gesture[];
        create<T extends typeof Gesture>(Type: T, element: Element, listener: DefaultListener): Gesture<Data, Listener<Options, Data>>;
    }
}
declare module "flow" {
    import { PointerData, Pointers } from "utils";
    export class EventEmitter {
        private listenerMap;
        on(event: string, listener: Function): this;
        emit(event: string, ...args: any[]): boolean;
    }
    export class EventConfig {
        private events;
        constructor(...events: string[]);
        getEvents(): string[];
    }
    export interface FlowConfig {
        start: EventConfig;
        update: EventConfig;
        end: EventConfig;
        cancel: EventConfig;
    }
    export class Flow extends EventEmitter {
        private element;
        config: FlowConfig;
        startListen: Array<() => () => void>;
        continueListen: Array<() => () => void>;
        removeListeners: Array<() => void>;
        allPointers: Map<number, PointerData>;
        changedPointers: Map<number, PointerData>;
        pointers: Pointers;
        constructor(element: Element | Document, config: FlowConfig);
        private proxy(fn, evt);
        addDOMEventListener(element: Element, evt: string, fn: (evt: Event) => void): () => void;
        removeDOMEventListener(element: Element, evt: string, fn: () => void): void;
        bind(config: FlowConfig): {
            startListen: Array<() => () => void>;
            continueListen: Array<() => () => void>;
        };
        activate(): Array<() => void>;
        setPointers(_EVT: Event): void;
        start(evt: Event): void;
        update(evt: Event): void;
        end(evt: Event): void;
        cancel(evt: Event): void;
        continue(): void;
        stop(): void;
    }
}
declare module "listener-handle" {
    import { Gesture } from "gesture";
    import { DefaultListener } from "listener";
    export class ListenerHandle<T extends typeof Gesture> {
        Type: T;
        element: Element;
        listener: DefaultListener;
        constructor(Type: T, element: Element, listener: DefaultListener);
    }
}
declare module "engine" {
    import { Registry } from "registry";
    import { Gesture, DefaultGesture } from "gesture";
    import { Listener, DefaultListener } from "listener";
    import { Flow } from "flow";
    import { Options, Data, Pointers } from "utils";
    export interface PointersDelta {
        all: number;
        changed: number;
    }
    export interface ExecStrategyState {
        evt: Event;
        gestures: DefaultGesture[];
        gesture: DefaultGesture;
        pointers: Pointers;
        pointersDelta: PointersDelta;
    }
    export type ExecStrategy = (state: ExecStrategyState) => number;
    export class Engine {
        private element;
        private registry;
        private flows;
        private activeFlow;
        private handles;
        private gestures;
        private composedGestures;
        constructor(element: Element | Document, registry?: Registry);
        registerGesture<G extends typeof Gesture, O extends typeof Options, L extends typeof Listener, D extends typeof Data>(Gesture: G, GestureOptions?: O, GestureListener?: L, GestureData?: D): void;
        registerFlow(flow: Flow): void;
        registerListener<T extends typeof Gesture>(Type: T, element: Element, listener: DefaultListener): () => void;
        activate(): (() => void)[][];
        private canActivateFlow(flow);
        private getPointersDelta(evt, pointers, configuredPointers, configuredWhich);
        private removeGesture(gesture, ...arr);
        private evaluateStrategyReturnFlag(gesture, flag);
        private whileGestures(evt, gestures, pointers, execStrategy);
        private addPointerId(gesture, pointerId);
        private removePointerIds(map, gesture, changed);
        private getPointerIds(gesture);
        private getRemovedPointers(gesture);
        private getPointer(map, pointerId);
        private getPointers(map, pointerIds);
        private isLockedPointers(gesture, map);
        private startStrategy(state);
        private updateStrategy(state);
        private endStrategy(state);
        private cancelStrategy(state);
        private onStart(flow, evt, pointers);
        private onUpdate(flow, evt, pointers);
        private onEnd(flow, evt, pointers);
        private onCancel(flow, evt, pointers);
        private onStop();
        private addGesture<T>(Type, element, handle, evt);
        private composeGesture<T>(Type, element, handle, evt);
        private matchesHandle<T>(element, handle);
        private matchHandle<T>(Type, element, handle, evt);
        private matchHandles(element, gestures, evt);
        private match(target, evt);
    }
}
declare module "flows/pointer" {
    import { Flow, FlowConfig, EventConfig } from "flow";
    export const PointerConfig: {
        start: EventConfig;
        update: EventConfig;
        end: EventConfig;
        cancel: EventConfig;
    };
    export class PointerFlow extends Flow {
        constructor(element: Element | Document, config?: FlowConfig);
        setPointers(evt: PointerEvent): void;
    }
}
declare module "flows/ms-pointer" {
    import { EventConfig } from "flow";
    import { PointerFlow } from "flows/pointer";
    export const MSPointerConfig: {
        start: EventConfig;
        update: EventConfig;
        end: EventConfig;
        cancel: EventConfig;
    };
    export class MSPointerFlow extends PointerFlow {
        constructor(element: Element | Document);
    }
}
declare module "flows/touch" {
    import { Flow, EventConfig } from "flow";
    import { PointerData } from "utils";
    export const TouchConfig: {
        start: EventConfig;
        update: EventConfig;
        end: EventConfig;
        cancel: EventConfig;
    };
    export class TouchFlow extends Flow {
        constructor(element: Element | Document);
        setPointerMapFromList(list: TouchList, pointerMap: Map<number, PointerData>): void;
        setPointers(evt: TouchEvent): void;
    }
}
declare module "flows/mouse" {
    import { Flow, EventConfig } from "flow";
    export const MouseConfig: {
        start: EventConfig;
        update: EventConfig;
        end: EventConfig;
        cancel: EventConfig;
    };
    export class MouseFlow extends Flow {
        constructor(element: Element | Document);
        setPointers(evt: MouseEvent): void;
    }
}
declare module "oribella-api" {
    import { Gesture } from "gesture";
    import { Listener, DefaultListener } from "listener";
    import { Options, Data, Supports } from "utils";
    export interface ListenerType {
        type: string;
        listener: Partial<DefaultListener>;
    }
    export class OribellaApi {
        private element;
        private engine;
        private deactivateFlows;
        constructor(element?: Element | Document);
        registerDefaultFlowStrategy(supports?: Supports): void;
        registerGesture<G extends typeof Gesture, O extends typeof Options, L extends typeof Listener, D extends typeof Data>(Gesture: G, GestureOptions?: O, GestureListener?: L, GestureData?: D): void;
        activate(): void;
        deactivate(): void;
        on<T extends typeof Gesture>(Type: T, element: Element, listener: DefaultListener): () => void;
    }
}
declare module "oribella-framework" {
    export * from "point";
    export * from "utils";
    export * from "listener";
    export * from "gesture";
    export * from "oribella-api";
}