phaser/build/phaser.d.ts

declare class SAT {

    flattenPointsOn(points: Array<SAT.Vector>, normal: SAT.Vector, result: Array<number>): Array<number>;
    isSeparatingAxis(aPos: SAT.Vector, bPos: SAT.Vector, aPoints: Array<SAT.Vector>, bPoints: Array<SAT.Vector>, axis: SAT.Vector, response: SAT.Response): boolean;
    vornoiRegion(line: SAT.Vector, point: SAT.Vector): number;
    testCircleCircle(a: SAT.Circle, b: SAT.Circle, response: SAT.Response): boolean;
    testPolygonCircle(a: SAT.Polygon, b: SAT.Circle, response: SAT.Response): boolean;
    testCirclePolygon(a: SAT.Circle, b: SAT.Polygon, response: SAT.Response): boolean;
    testPolygonPolygon(a: SAT.Polygon, b: SAT.Polygon, response: SAT.Response): boolean;

}

declare module SAT {

    class Vector {
        constructor(x: number, y: number);
        x: number;
        y: number;
        copy(other: SAT.Vector): SAT.Vector;
        perp(): SAT.Vector;
        rotate(angle: number): SAT.Vector;
        rotatePrecalc(sin: number, cos: number): SAT.Vector;
        reverse(): SAT.Vector;
        normalize(): SAT.Vector;
        add(other: SAT.Vector): SAT.Vector;
        sub(other: SAT.Vector): SAT.Vector;
        scale(x: number, y: number): SAT.Vector;
        project(other: SAT.Vector): SAT.Vector;
        projectN(other: SAT.Vector): SAT.Vector;
        reflect(axis: SAT.Vector): SAT.Vector;
        reflectN(axis: SAT.Vector): SAT.Vector;
        dot(other: SAT.Vector): SAT.Vector;
        len2(): SAT.Vector;
        len(): SAT.Vector;
    }

    class Circle {
        constructor(pos: SAT.Vector, radius: number);
        pos: SAT.Vector;
        r: number;
    }

    class Polygon {
        constructor(pos: SAT.Vector, points: Array<SAT.Vector>);
        pos: SAT.Vector;
        points: Array<SAT.Vector>;
        recalc(): SAT.Polygon;
        rotate(angle: number): SAT.Polygon;
        scale(x: number, y: number): SAT.Polygon;
        translate(x: number, y: number): SAT.Polygon;
    }

    class Box {
        constructor(pos: SAT.Vector, w: number, h: number);
        pos: SAT.Vector;
        w: number;
        h: number;
        toPolygon(): SAT.Polygon;
    }

    class Response {
        constructor();
        a: any;
        b: any;
        overlapN: SAT.Vector;
        overlapV: SAT.Vector;
        clear(): SAT.Response;
        aInB: boolean;
        bInA: boolean;
        overlap: number;
    }
}

declare class Phaser {
    static VERSION: string;
    static DEV_VERSION: string;
    static GAMES: Array<Phaser.Game>;
    static AUTO: number;
    static CANVAS: number;
    static WEBGL: number;
    static SPRITE: number;
    static BUTTON: number;
    static BULLET: number;
    static GRAPHICS: number;
    static TEXT: number;
    static TILESPRITE: number;
    static BITMAPTEXT: number;
    static GROUP: number;
    static RENDERTEXTURE: number;
    static TILEMAP: number;
    static TILEMAPLAYER: number;
    static EMITTER: number;
    static BITMAPDATA: number;
    static CANVAS_FILTER: number;
    static WEBGL_FILTER: number;
}

declare module Phaser {
    class Camera {
        constructor(game: Phaser.Game, id: number, x: number, y: number, width: number, height: number);
        game: Phaser.Game;
        world: Phaser.World;
        id: number;
        x: number;
        y: number;
        width: number;
        height: number;
        view: Phaser.Rectangle;
        screenView: Phaser.Rectangle;
        bounds: Phaser.Rectangle;
        deadzone: Phaser.Rectangle;
        visible: boolean;
        atLimit: { x: boolean; y: boolean; };
        target: Phaser.Sprite;
        private _edge: number;
        static FOLLOW_LOCKON: number;
        static FOLLOW_PLATFORMER: number;
        static FOLLOW_TOPDOWN: number;
        static FOLLOW_TOPDOWN_TIGHT: number;
        follow(target: Phaser.Sprite, style?: number): void;
        focusOnXY(x: number, y: number): void;
        update(): void;
        checkWorldBounds(): void;
        setPosition(x: number, y: number): void;
        setSize(width: number, height: number): void;
    }

    class State {
        game: Phaser.Game;
        add: Phaser.GameObjectFactory;
        camera: Phaser.Camera;
        cache: Phaser.Cache;
        input: Phaser.Input;
        load: Phaser.Loader;
        stage: Phaser.Stage;
        math: Phaser.Math;
        sound: Phaser.SoundManager;
        time: Phaser.Time;
        tweens: Phaser.TweenManager;
        world: Phaser.World;
        particles: Phaser.Particles;
        physics: Phaser.Physics.Arcade;
        preload();
        loadUpdate();
        loadRender();
        create();
        update();
        render();
        paused();
        destroy();
    }

    class StateManager {
        constructor(game: Phaser.Game, pendingState: Phaser.State);
        game: Phaser.Game;
        states: { [key: string]: Phaser.State };
        current: string;
        onInitCallback(): void;
        onPreloadCallback(): void;
        onCreateCallback(): void;
        onUpdateCallback(): void;
        onRenderCallback(): void;
        onPreRenderCallback(): void;
        onLoadUpdateCallback(): void;
        onLoadRenderCallback(): void;
        onPausedCallback(): void;
        onShutDownCallback(): void;
        boot(): void;
        add(key: string, state: any, autoStart?: boolean): void;
        remove(key: string): void;
        start(key: string, clearWorld?: boolean, clearCache?: boolean): void;
        dummy(): void;
        checkState(key: string): boolean;
        link(key: string): void;
        getCurrentState(): Phaser.State;
        loadComplete(): void;
        update(): void;
        preRender(): void;
        render(): void;
        destroy(): void;
    }

    class LinkedListItem {
        next: LinkedListItem;
        prev: LinkedListItem;
        first: LinkedListItem;
        last: LinkedListItem;
    }

    class LinkedList extends LinkedListItem {
        total: number;
        add(child: LinkedListItem): LinkedListItem;
        remove(child: LinkedListItem): void;
        callAll(callback: string): void;
        dump(): void;
    }

    class Signal {
        memorize: boolean;
        active: boolean;
        validateListener(listener: Function, fnName: string): void;
        has(listener: Function, context?: any): boolean;
        add(listener: Function, listenerContext?: any, priority?: number): Phaser.SignalBinding;
        addOnce(listener: Function, listenerContext?: any, priority?: number): Phaser.SignalBinding;
        remove(listener: Function, context?: any): Function;
        removeAll(): void;
        getNumListeners(): number;
        halt(): void;
        dispatch(...params: any[]): void;
        forget(): void;
        dispose(): void;
        toString(): string;
    }

    class SignalBinding {
        constructor(signal: Phaser.Signal, listener: Function, isOnce: boolean, listenerContext: Object, priority?: number);
        context: Object;
        active: boolean;
        params: Array<any>;
        execute(paramsArr?: Array<any>): void;
        detach(): Function;
        isBound(): boolean;
        isOnce(): boolean;
        getListener(): Function;
        getSignal(): Phaser.Signal;
        toString(): string;
    }

    class StateCycle {
        preUpdate(): void;
        update(): void;
        render(): void;
        postRender(): void;
        destroy(): void;
    }

    class Plugin extends StateCycle {
        constructor(game: Phaser.Game, parent: any);
        game: Phaser.Game;
        parent: any;
        active: boolean;
        visible: boolean;
        hasPreUpdate: boolean;
        hasUpdate: boolean;
        hasRender: boolean;
        hasPostRender: boolean;
    }

    class PluginManager extends StateCycle {
        constructor(game: Phaser.Game, parent: any);
        game: Phaser.Game;
        private _parent: any;
        plugins: Phaser.Plugin[];
        add(plugin: Phaser.Plugin): Phaser.Plugin;
        remove(plugin: Phaser.Plugin): void;
    }

    class Stage {
        constructor(game: Phaser.Game, width: number, height: number);
        game: Phaser.Game;
        offset: Phaser.Point;
        canvas: HTMLCanvasElement;
        scaleMode: number;
        scale: Phaser.StageScaleMode;
        aspectRatio: number;
        backgroundColor: string;
        disableVisibilityChange: boolean;
        boot(): void;
        visibilityChange(event: Event): void;
    }

    // Wraps a PIXI.DisplayObjectContainer
    class Group {
        constructor(game: Phaser.Game, parent?: any, name?: string, useStage?: boolean);
        game: Phaser.Game;
        name: string;
        type: number;
        exists: boolean;
        sortIndex: string;
        length: number;
        x: number;
        y: number;
        angle: number;
        rotation: number;
        visible: boolean;
        add(child: any): any;
        addAt(child: any, index: number): any;
        getAt(index: number): any;
        create(x: number, y: number, key: string, frame?: any, exists?: boolean): Phaser.Sprite;
        swap(child1: any, child2: any): boolean;
        bringToTop(child: any): any;
        getIndex(child: any): number;
        replace(oldChild: any, newChild: any): void;
        setProperty(child: any, key: string[], value: string, operation: number): void;
        setAll(key: string, value: number, checkAlive: boolean, checkVisible: boolean, operation: number): void;
        subAll(key: string, value: number, checkAlive: boolean, checkVisible: boolean, operation: number): void;
        multiplyAll(key: string, value: number, checkAlive: boolean, checkVisible: boolean, operation: number): void;
        divideAll(key: string, value: number, checkAlive: boolean, checkVisible: boolean, operation: number): void;
        callAllExists(callback: Function, callbackContext: Object, existsValue: boolean): void;
        callAll(callback: string, callbackContext?: Object): void;
        forEach(callback: Function, callbackContext: Object, checkExists: boolean): void;
        forEachAlive(callback: Function, callbackContext: Object): void;
        forEachDead(callback: Function, callbackContext: Object): void;
        getFirstExists(state: boolean): any;
        getFirstAlive(): any;
        getFirstDead(): any;
        countLiving(): number;
        countDead(): number;
        getRandom(startIndex: number, length: number): any;
        remove(child: any): void;
        removeAll(): void;
        removeBetween(startIndex: number, endIndex: number): void;
        destroy(): void;
        dump(full: boolean): void;
    }

    class World extends Phaser.Group {
        constructor(game: Phaser.Game);
        game: Phaser.Game;
        bounds: Phaser.Rectangle;
        camera: Phaser.Camera;
        currentRenderOrderID: number;
        group: Phaser.Group;
        width: number;
        height: number;
        centerX: number;
        centerY: number;
        randomX: number;
        randomY: number;
        boot(): void;
        update(): void;
        setBounds( x:number, y:number, width: number, height: number): void;
        destroy(): void;
    }

    class Game {
        /*
         * Defaults:
         * [width=800] - The width of your game in game pixels.
         * [height=600] - The height of your game in game pixels.
         * [renderer=Phaser.AUTO] - Which renderer to use: Phaser.AUTO will auto-detect, Phaser.WEBGL, Phaser.CANVAS or Phaser.HEADLESS (no rendering at all).
         * [parent=''] - The Games DOM parent.
         * [state=null] - Description.
         * [transparent=false] - Use a transparent canvas background or not.
         * [antialias=true] - Anti-alias graphics.
         * */
        constructor(width?: number, height?: number, renderer?: number, parent?: string, state?: Object, transparent?: boolean, antialias?: boolean);
        id: number;
        width: number;
        height: number;
        renderer: number;
        transparent: boolean;
        antialias: boolean;
        parent: string;
        state: Phaser.StateManager;
        renderType: number;
        isBooted: boolean;
        raf: Phaser.RequestAnimationFrame;
        add: Phaser.GameObjectFactory;
        cache: Phaser.Cache;
        input: Phaser.Input;
        load: Phaser.Loader;
        math: Phaser.Math;
        sound: Phaser.SoundManager;
        stage: Phaser.Stage;
        time: Phaser.Time;
        tweens: Phaser.TweenManager;
        world: Phaser.World;
        physics: Phaser.Physics.Arcade;
        rnd: Phaser.RandomDataGenerator;
        device: Phaser.Device;
        camera: Phaser.Camera;
        canvas: HTMLCanvasElement;
        context: Object;
        debug: Phaser.Utils.Debug;
        particles: Phaser.Particles;
        _paused: boolean;
        paused: boolean;
        boot(): void;
        setUpRenderer(): void;
        loadComplete(): void;
        update(): void;
        destroy(): void;
    }

    class Input {
        constructor(game: Phaser.Game);
        static MOUSE_OVERRIDES_TOUCH: number;
        static TOUCH_OVERRIDES_MOUSE: number;
        static MOUSE_TOUCH_COMBINE: number;
        id: number;
        active: boolean;
        game: Phaser.Game;
        hitCanvas: any;
        hitContext: any;
        pollRate: number;
        disabled: boolean;
        multiInputOverride: number;
        position: Phaser.Point;
        speed: Phaser.Point;
        circle: Phaser.Circle;
        scale: Phaser.Point;
        maxPointers: number;
        currentPointers: number;
        tapRate: number;
        doubleTapRate: number;
        holdRate: number;
        justPressedRate: number;
        justReleasedRate: number;
        recordPointerHistory: boolean;
        recordRate: number;
        recordLimit: number;
        x: number;
        y: number;
        totalInactivePointers: number;
        totalActivePointers: number;
        worldX: number;
        worldY: number;
        pollLocked: boolean;
        pointer1: Phaser.Pointer;
        pointer2: Phaser.Pointer;
        pointer3: Phaser.Pointer;
        pointer4: Phaser.Pointer;
        pointer5: Phaser.Pointer;
        pointer6: Phaser.Pointer;
        pointer7: Phaser.Pointer;
        pointer8: Phaser.Pointer;
        pointer9: Phaser.Pointer;
        pointer10: Phaser.Pointer;
        activePointer: Phaser.Pointer;
        mousePointer: Phaser.Pointer;
        mouse: Phaser.Mouse;
        keyboard: Phaser.Keyboard;
        touch: Phaser.Touch;
        mspointer: Phaser.MSPointer;
        interactiveItems: Phaser.LinkedList;
        onDown: Phaser.Signal;
        onUp: Phaser.Signal;
        onTap: Phaser.Signal;
        onHold: Phaser.Signal;
        boot(): void;
        update(): void;
        reset(hard?: boolean);
        resetSpeed(x: number, y: number);
        startPointer(event: Event): Phaser.Pointer;
        updatePointer(event: Event): Phaser.Pointer;
        stopPointer(event: Event): Phaser.Pointer;
        getPointer(state: boolean): Phaser.Pointer;
        getPointerFromIdentifier(identifier: number): Phaser.Pointer;
        addPointer(): Phaser.Pointer;
    }

    class Key {
        constructor( game:Phaser.Game, keycode:number )
        isDown:boolean;
        isUp:boolean;
        altKey:boolean;
        ctrlKey:boolean;
        shiftKey:boolean;
        timeDown:number;
        duration:number;
        timeUp:number;
        repeats:number;
        keycode:number;
        onDown:Phaser.Signal;
        onUp:Phaser.Signal;
        justPressed( duration:number ):boolean;
        justReleased( duration:number ):boolean;
    }

    interface CursorKeys
    {
        up:Phaser.Key;
        down:Phaser.Key;
        left:Phaser.Key;
        right:Phaser.Key;
    }

    class Keyboard {
        constructor(game: Phaser.Game);
        game: Phaser.Game;
        disabled: boolean;
        static A: number;
        static B: number;
        static C: number;
        static D: number;
        static E: number;
        static F: number;
        static G: number;
        static H: number;
        static I: number;
        static J: number;
        static K: number;
        static L: number;
        static M: number;
        static N: number;
        static O: number;
        static P: number;
        static Q: number;
        static R: number;
        static S: number;
        static T: number;
        static U: number;
        static V: number;
        static W: number;
        static X: number;
        static Y: number;
        static Z: number;
        static ZERO: number;
        static ONE: number;
        static TWO: number;
        static THREE: number;
        static FOUR: number;
        static FIVE: number;
        static SIX: number;
        static SEVEN: number;
        static EIGHT: number;
        static NINE: number;
        static NUMPAD_0: number;
        static NUMPAD_1: number;
        static NUMPAD_2: number;
        static NUMPAD_3: number;
        static NUMPAD_4: number;
        static NUMPAD_5: number;
        static NUMPAD_6: number;
        static NUMPAD_7: number;
        static NUMPAD_8: number;
        static NUMPAD_9: number;
        static NUMPAD_MULTIPLY: number;
        static NUMPAD_ADD: number;
        static NUMPAD_ENTER: number;
        static NUMPAD_SUBTRACT: number;
        static NUMPAD_DECIMAL: number;
        static NUMPAD_DIVIDE: number;
        static F1: number;
        static F2: number;
        static F3: number;
        static F4: number;
        static F5: number;
        static F6: number;
        static F7: number;
        static F8: number;
        static F9: number;
        static F10: number;
        static F11: number;
        static F12: number;
        static F13: number;
        static F14: number;
        static F15: number;
        static COLON: number;
        static EQUALS: number;
        static UNDERSCORE: number;
        static QUESTION_MARK: number;
        static TILDE: number;
        static OPEN_BRACKET: number;
        static BACKWARD_SLASH: number;
        static CLOSED_BRACKET: number;
        static QUOTES: number;
        static BACKSPACE: number;
        static TAB: number;
        static CLEAR: number;
        static ENTER: number;
        static SHIFT: number;
        static CONTROL: number;
        static ALT: number;
        static CAPS_LOCK: number;
        static ESC: number;
        static SPACEBAR: number;
        static PAGE_UP: number;
        static PAGE_DOWN: number;
        static END: number;
        static HOME: number;
        static LEFT: number;
        static UP: number;
        static RIGHT: number;
        static DOWN: number;
        static INSERT: number;
        static DELETE: number;
        static HELP: number;
        static NUM_LOCK: number;
        start(): void;
        stop(): void;
        addKey(keycode: number): Phaser.Key;
        addKeyCapture(keycode: any): void;
        removeKeyCapture(keycode: number): void;
        clearCaptures(): void;
        onKeyDown(event: any): void;
        onKeyUp(event: any): void;
        reset(): void;
        justPressed(keycode: number, duration?: number): boolean;
        justReleased(keycode: number, duration?: number): boolean;
        isDown(keycode: number): boolean;
        createCursorKeys():CursorKeys;
    }

    class Mouse {
        constructor(game: Phaser.Game)
        game: Phaser.Game;
        callbackContext: Object;
        disabled: boolean;
        locked: boolean;
        static LEFT_BUTTON: number;
        static MIDDLE_BUTTON: number;
        static RIGHT_BUTTON: number;
        mouseDownCallback: Function;
        mouseMoveCallback: Function;
        mouseUpCallback: Function;
        start(): void;
        onMouseDown(): void;
        onMouseUp(): void;
        onMouseMove(): void;
        requestPointerLock(): void;
        pointerLockChange(): void;
        releasePointerLock(): void;
        stop();
    }

    class MSPointer {
        constructor(game: Phaser.Game);
        game: Phaser.Game;
        callbackContext: Object;
        disabled: boolean;
        mouseDownCallback(): void;
        mouseMoveCallback(): void;
        mouseUpCallback(): void;
        start(): void;
        onPointerDown(): void;
        onPointerUp(): void;
        onPointerMove(): void;
        stop(): void;
    }

    class Pointer {
        constructor(game: Phaser.Game, id: number);
        game: Phaser.Game;
        id: number;
        active: boolean;
        positionDown: Phaser.Point;
        position: Phaser.Point;
        circle: Phaser.Circle;
        withinGame: boolean;
        clientX: number;
        clientY: number;
        pageX: number;
        pageY: number;
        screenX: number;
        screenY: number;
        duation: number;
        worldX: number;
        worldY: number;
        x: number;
        y: number;
        isMouse: boolean;
        isDown: boolean;
        isUp: boolean;
        timeDown: number;
        timeUp: number;
        previousTapTime: number;
        totalTouches: number;
        msSinceLastClick: number;
        targetObject: any;
        start(event: any): Phaser.Pointer;
        update(): void;
        move(event: any): void;
        leave(event: any): void;
        stop(event: any): void;
        justPressed(duration?: number): boolean;
        justReleased(duration?: number): boolean;
        reset(): void;
        toString(): string;
    }

    class Touch {
        constructor(game: Phaser.Game);
        game: Phaser.Game;
        callbackContext: any;
        touchStartCallback: Function;
        touchMoveCallback: Function;
        touchEndCallback: Function;
        touchEnterCallback: Function;
        touchLeaveCallback: Function;
        touchCancelCallback: Function;
        preventDefault: boolean;
        disabled: boolean;
        start(): void;
        consumeDocumentTouches(): void;
        onTouchStart(event: any): void;
        onTouchCancel(event: any): void;
        onTouchEnter(event: any): void;
        onTouchLeave(event: any): void;
        onTouchMove(event: any): void;
        onTouchEnd(event: any): void;
        stop(): void;
    }

    class InputHandler extends LinkedListItem {
        constructor(sprite: Phaser.Sprite);
        game: Phaser.Game;
        sprite: Phaser.Sprite;
        enabled: boolean;
        priorityID: number;
        useHandCursor: boolean;
        isDragged: boolean;
        allowHorizontalDrag: boolean;
        allowVerticalDrag: boolean;
        bringToTop: boolean;
        snapOffset: number;
        snapOnDrag: boolean;
        snapOnRelease: boolean;
        snapX: number;
        snapY: number;
        pixelPerfect: boolean;
        pixelPerfectAlpha: number;
        draggable: boolean;
        boundsSprite: Phaser.Sprite;
        consumePointerEvent: boolean;
        start(priority: number, useHandCursor: boolean): void;
        reset(): void;
        stop(): void;
        destroy(): void;
        pointerX(pointer: number): number;
        pointerY(pointer: number): number;
        pointerDown(pointer: number): boolean;
        pointerUp(pointer: number): boolean;
        pointerTimeDown(pointer: number): number;
        pointerTimeUp(pointer: number): number;
        pointerOver(pointer: number): boolean;
        pointerOut(pointer: number): boolean;
        pointerTimeOver(pointer: number): number;
        pointerTimeOut(pointer: number): number;
        pointerDragged(pointer: number): boolean;
        checkPointerOver(pointer: number): boolean;
        checkPixel(x: number, y: number): boolean;
        update(pointer: number): void;
        updateDrag(pointer: number): boolean;
        justOver(pointer: number, delay: number): boolean;
        justOut(pointer: number, delay: number): boolean;
        justPressed(pointer: number, delay: number): boolean;
        justReleased(pointer: number, delay: number): boolean;
        overDuration(pointer: number): number;
        downDuration(pointer: number): number;
        enableDrag(lockCenter: boolean, bringToTop: boolean, pixelPerfect: boolean, alphaThreshold?: number, boundsRect?: Phaser.Rectangle, boundsSprite?: Phaser.Rectangle): void;
        disableDrag(): void;
        startDrag(): void;
        stopDrag(): void;
        setDragLock(allowHorizontal: boolean, allowVertical: boolean): void;
        enableSnap(snapX: number, snapY: number, onDrag?: boolean, onRelease?: boolean): void;
        disableSnap(): void;
        checkBoundsRect(): void;
        checkBoundsSprite(): void;
    }

    class Event {
        constructor(sprite: Phaser.Sprite);
        parent: Phaser.Sprite;
        onAddedToGroup: Phaser.Signal;
        onRemovedFromGroup: Phaser.Signal;
        onKilled: Phaser.Signal;
        onRevived: Phaser.Signal;
        onOutOfBounds: Phaser.Signal;
        onInputOver: Phaser.Signal;
        onInputOut: Phaser.Signal;
        onInputDown: Phaser.Signal;
        onInputUp: Phaser.Signal;
        onDragStart: Phaser.Signal;
        onDragStop: Phaser.Signal;
        onAnimationStart: Phaser.Signal;
        onAnimationComplete: Phaser.Signal;
        onAnimationLoop: Phaser.Signal;
    }

    class GameObjectFactory {
        constructor(game: Phaser.Game);
        game: Phaser.Game;
        world: Phaser.World;
        existing(object: any): any;
        sprite(x: number, y: number, key?: string, frame?: any): Phaser.Sprite;
        child(parent: any, x: number, y: number, key?: string, frame?: number): Phaser.Sprite;
        tween(obj: Object): Phaser.Tween;
        group(parent?: any, name?: string): Phaser.Group;
        audio(key: string, volume?: number, loop?: boolean): Phaser.Sound;
        tileSprite(x: number, y: number, width: number, height: number, key?: string, frame?: number): Phaser.TileSprite;
        text(x: number, y: number, text: string, style: any): Phaser.Text;
        button(x: number, y: number, key: string, callback: Function, callbackContext: Object, overFrame?: any, outFrame?: any, downFrame?: any): Phaser.Button;
        graphics(x: number, y: number): Phaser.Graphics;
        emitter(x: number, y: number, maxParticles: number): Phaser.Particles.Arcade.Emitter;
        bitmapText(x: number, y: number, text: string, style: any): Phaser.BitmapText;
        tilemap(x: number, y: number, key: string, resizeWorld: boolean, tileWidth: number, tileHeight: number): Phaser.Tilemap;
        renderTexture(key: string, width: number, height: number): Phaser.RenderTexture;
    }

    class Sprite {
        constructor(game: Phaser.Game, x?: number, y?: number, key?: string, frame?: number);
        game: Phaser.Game;
        exists: boolean;
        alive: boolean;
        group: Phaser.Group;
        name: string;
        type: number;
        renderOrderID: number;
        lifespan: number;
        events: Phaser.Events;
        animations: Phaser.AnimationManager;
        input: Phaser.InputHandler;
        key: string;
        currentFrame: number;
        anchor: Phaser.Point;
        x: number;
        y: number;
        cameraOffset:Phaser.Point;
        position: Phaser.Point;
        autoCull: boolean;
        scale: Phaser.Point;
        scrollFactor: Phaser.Point;
        offset: Phaser.Point;
        center: Phaser.Point;
        topLeft: Phaser.Point;
        topRight: Phaser.Point;
        bottomRight: Phaser.Point;
        bottomLeft: Phaser.Point;
        bounds: Phaser.Rectangle;
        body: Phaser.Physics.Arcade.Body;
        inWorld: boolean;
        inWorldThreshold: number;
        angle: number;
        frame: number;
        frameName: string;
        inCamera: boolean;
        crop: Phaser.Rectangle;
        cropEnabled: boolean;
        inputEnabled: boolean;
        fixedToCamera:boolean;
        preUpdate(): void;
        postUpdate(): void;
        centerOn(x: number, y: number): void;
        revive(): void;
        kill(): void;
        reset(x: number, y: number): void;
        updateBounds(): void;
        getLocalPosition(p: Phaser.Point, x: number, y: number): Phaser.Point;
        getLocalUnmodifiedPosition(p: Phaser.Point, x: number, y: number): Phaser.Point;
        bringToTop(): void;
        getBounds(rect: Phaser.Rectangle): Phaser.Rectangle;
        alpha: number;
        visible: boolean;
        renderable: boolean;
        width: number;
        height: number;
        health: number;
        damage(amount: number): Phaser.Sprite;
    }

    class Events {
        parent: Phaser.Sprite;
        onAddedToGroup: Phaser.Signal;
        onRemovedFromGroup: Phaser.Signal;
        onKilled: Phaser.Signal;
        onRevived: Phaser.Signal;
        onOutOfBounds: Phaser.Signal;
        onInputOver: Phaser.Signal;
        onInputOut: Phaser.Signal;
        onInputDown: Phaser.Signal;
        onInputUp: Phaser.Signal;
        onDragStart: Phaser.Signal;
        onDragStop: Phaser.Signal;
        onAnimationStart: Phaser.Signal;
        onAnimationComplete: Phaser.Signal;
        onAnimationLoop: Phaser.Signal;
    }

    class TileSprite extends Sprite {
        constructor(game: Phaser.Game, x: number, y: number, width: number, height: number, key?: string, frame?: number);
        texture: Phaser.RenderTexture;
        type: number;
        tileScale: Phaser.Point;
        tilePosition: Phaser.Point;
    }

    class Text {
        constructor(game: Phaser.Game, x: number, y: number, text: string, style: any);
        exists: boolean;
        alive: boolean;
        group: Phaser.Group;
        content: string;
        name: string;
        game: Phaser.Game;
        type: number;
        text: string;
        angle: number;
        style: any;
        visible: boolean;
        position: Phaser.Point;
        anchor: Phaser.Point;
        scale: Phaser.Point;
        scrollFactor: Phaser.Point;
        renderable: boolean;
        update(): void;
    }

    class BitmapText extends Phaser.Text {
        constructor(game: Phaser.Game, x?: number, y?: number, text?: string, style?: Object);
	    alive: boolean;
	    anchor: Phaser.Point;
	    angle: number;
	    exist: boolean;
	    game: Phaser.Game;
	    group: Phaser.Group;
	    name: string;
	    renderable: boolean;
	    scale: Phaser.Point;
	    type: number; // readonly
		x: number;
	    y: number;
	    update(): void;
    }

    class Button {
        constructor(game: Phaser.Game, x: number, y: number, key: string, callback: Function, overFrame: number, outFrame: number, downFrame: number);
        input: Phaser.InputHandler;
        onInputUp: Phaser.Signal;
        onInputDown: Phaser.Signal;
        onInputOut: Phaser.Signal;
        onInputOver: Phaser.Signal;
        events: Phaser.Event[];
        setFrames(overFrame?: number, outFrame?: number, downFrame?: number): void;
        onInputOverHandler(pointer: Phaser.Pointer): void;
        onInputUpHandler(pointer: Phaser.Pointer): void;
        onInputDownHandler(pointer: Phaser.Pointer): void;
        onInputOutHandler(pointer: Phaser.Pointer): void;
    }


    // Actually extends PIXI.Graphics but we skip the abstraction here, since pixi is "part" of phaser
    // PIXI.Graphics extends PIXI.DisplayObjectContainer extends DisplayObject
    class Graphics extends Phaser.Sprite {
        constructor(game: Phaser.Game, x: number, y: number);
        angle: number;
        x:number;
        y:number;

        // Pixi drawing
        lineStyle(lineWidth:number, color?:number, alpha?:number): void;
        moveTo(x:number, y:number): void;
        lineTo(x:number, y:number): void;
        beginFill(color:number, alpha?:number): void;
        endFill(): void;
        drawRect( x:number, y:number, width:number, height:number ): void;
        drawCircle( x:number, y:number, radius:number): void;
        drawElipse( x:number, y:number, width:number, height:number): void;
        clear(): void;
        updateFilterBounds(): void;
    }

    class RenderTexture {
        constructor(game: Phaser.Game, key: string, width: number, height: number);
        name: string;
        type: number;
    }

    class Canvas {
        create(width: number, height: number): HTMLCanvasElement;
        getOffset(element: HTMLElement, point?: Phaser.Point): Phaser.Point;
        getAspectRatio(canvas: HTMLCanvasElement): number;
        setBackgroundColor(canvas: HTMLCanvasElement, color: string): HTMLCanvasElement;
        setTouchAction(canvas: HTMLCanvasElement, value: string): HTMLCanvasElement;
        addToDOM(canvas: HTMLCanvasElement, parent: string, overflowHidden: boolean): HTMLCanvasElement;
        setTransform(context: CanvasRenderingContext2D, translateX: number, translateY: number, scaleX: number, scaleY: number, skewX: number, skewY: number): CanvasRenderingContext2D;
        setSmoothingEnabled(context: CanvasRenderingContext2D, value: boolean): CanvasRenderingContext2D;
        setImageRenderingCrisp(canvas: HTMLCanvasElement): HTMLCanvasElement;
        setImageRenderingBicubic(canvas: HTMLCanvasElement): HTMLCanvasElement;
    }

    class StageScaleMode {
        constructor(game: Phaser.Game, width: number, height: number);
        static EXACT_FIT: number;
        static NO_SCALE: number;
        static SHOW_ALL: number;
        forceLandscape: boolean;
        forcePortrait: boolean;
        incorrectOrientation: boolean;
        pageAlignHorizontally: boolean;
        pageAlignVertically: boolean;
        minWidth: number;
        maxWidth: number;
        minHeight: number;
        maxHeight: number;
        width: number;
        height: number;
        maxIterations: number;
        game: Phaser.Game;
        enterLandscape: Phaser.Signal;
        enterPortrait: Phaser.Signal;
        orientation: number;
        scaleFactor: Phaser.Point;
        aspectRatio: number;
        isFullScreen: boolean;
        isPortrait: boolean;
        isLandscape: boolean;
        startFullScreen(): void;
        stopFullScreen(): void;
        checkOrientationState(): void;
        checkOrientation(): void;
        checkResize(event: any): void;
        refresh(): void;
        setScreenSize(force: boolean): void;
        setSize(): void;
        setMaximum(): void;
        setShowAll(): void;
        setExactFit(): void;
    }

    class Device {
        patchAndroidClearRect: boolean;
        desktop: boolean;
        iOS: boolean;
        android: boolean;
        chromeOS: boolean;
        linux: boolean;
        macOS: boolean;
        windows: boolean;
        canvas: boolean;
        file: boolean;
        fileSystem: boolean;
        localStorage: boolean;
        webGL: boolean;
        worker: boolean;
        touch: boolean;
        mspointer: boolean;
        css3D: boolean;
        pointerLock: boolean;
        arora: boolean;
        chrome: boolean;
        epiphany: boolean;
        firefox: boolean;
        ie: boolean;
        ieVersion: number;
        mobileSafari: boolean;
        midori: boolean;
        opera: boolean;
        safari: boolean;
        webApp: boolean;
        audioData: boolean;
        webAudio: boolean;
        ogg: boolean;
        opus: boolean;
        mp3: boolean;
        wav: boolean;
        m4a: boolean;
        webm: boolean;
        iPhone: boolean;
        iPhone4: boolean;
        iPad: boolean;
        pixelRatio: number;
        canPlayAudio(type: string): boolean;
        isConsoleOpen(): boolean;
    }

    class RequestAnimationFrame {
        constructor(game: Phaser.Game);
        game: Phaser.Game;
        isRunning: boolean;
        start(): boolean;
        updateRAF(time: number): void;
        updateSetTimeout(): void;
        stop(): void;
        isSetTimeOut(): boolean;
        isRAF(): boolean;
    }

    class RandomDataGenerator {
        constructor(seeds: Array<number>);
        c: number;
        s0: number;
        s1: number;
        s2: number;
        rnd(): number;
        sow(seeds: Array<any>): void;
        hash(data: any): number;
        integer(): number;
        frac(): number;
        real(): number;
        integerInRange(min: number, max: number): number;
        realInRange(min: number, max: number): number;
        normal(): number;
        uuid(): number;
        pick(ary: number[]): number;
        weightedPick(ary: number[]): number;
        timestamp(a?: number, b?: number): number;
        angle(): number;
    }

    class Math {
        static PI2: number;
        static fuzzyEqual(a: number, b: number, epsilon?: number): boolean;
        static fuzzyLessThan(a: number, b: number, epsilon?: number): boolean;
        static fuzzyGreaterThan(a: number, b: number, epsilon?: number): boolean;
        static fuzzyCeil(a: number, b: number, epsilon?: number): boolean;
        static fuzzyFloor(a: number, b: number, epsilon?: number): boolean;
        static average(...numbers: number[]): number;
        static truncate(n: number): number;
        static shear(n: number): number;
        static snapTo(input: number, gap: number, start?: number): number;
        static snapToFloor(input: number, gap: number, start?: number): number;
        static snapToCeil(input: number, gap: number, start?: number): number;
        static snapToInArray(input: number, arr: number[], sort?: boolean): number;
        static roundTo(value: number, place?: number, base?: number): number;
        static floorTo(value: number, place?: number, base?: number): number;
        static ceilTo(value: number, place?: number, base?: number): number;
        static interpolateFloat(a: number, b: number, weight: number): number;
        static angleBetween(x1: number, y1: number, x2: number, y2: number): number;
        static normalizeAngle(angle: number, radians?: boolean): number;
        static nearestAngleBetween(a1: number, a2: number, radians?: boolean): number;
        static interpolateAngles(a1: number, a2: number, weight: number, radians?: boolean, ease?: any): number;
        static chanceRoll(chance?: number): boolean;
        static numberArray(min: number, max: number): number[];
        static maxAdd(value: number, amount: number, max: number): number;
        static minSub(value: number, amount: number, min: number): number;
        static wrap(value: number, min: number, max: number): number;
        static wrapValue(value: number, amount: number, max: number): number;
        static randomSign(): number;
        static isOdd(n: number): boolean;
        static isEven(n: number): boolean;
        static max(...numbers: number[]): number;
        static min(...numbers: number[]): number;
        static wrapAngle(angle: number): number;
        static angleLimit(angle: number, min: number, max: number): number;
        static linearInterpolation(v: number[], k: number): number;
        static bezierInterpolation(v: number[], k: number): number;
        static catmullRomInterpolation(v: number[], k: number): number;
        static linear(p0: number, p1: number, t: number): number;
        static bernstein(n: number, i: number): number;
        static catmullRom(p0: number, p1: number, p2: number, p3: number, t: number): number;
        static difference(a: number, b: number): number;
        static getRandom(objects: Object[], startIndex?: number, length?: number): Object;
        static floor(value: number): number;
        static ceil(value: number): number;
        static sinCosGenerator(length: number, sinAmplitude?: number, cosAmplitude?: number, frequency?: number): { sin: number[]; cos: number[]; };
        static shift(stack: Array<any>): any;
        static shuffleArray(array: Array<any>): Array<any>;
        static distance(x1: number, y1: number, x2: number, y2: number): number;
        static distanceRounded(x1: number, y1: number, x2: number, y2: number): number;
        static clamp(x: number, a: number, b: number): number;
        static clampBottom(x: number, a: number): number;
        static mapLinear(x: number, a1: number, a2: number, b1: number, b2: number): number;
        static smoothstep(x: number, min: number, max: number): number;
        static smootherstep(x: number, min: number, max: number): number;
        static sign(x: number): number;
        static degToRad(degrees: number): number;
        static radToDeg(radians: number): number;
    }

    class QuadTree {
        constructor(x: number, y: number, width: number, height: number, maxObject?: number, maxLevels?: number, level?: number);
        maxObjects: number;
        maxLevels: number;
        level: number;
        bounds: {
            x: number;
            y: number;
            width: number;
            height: number;
            subWidth: number;
            subHeight: number;
            right: number;
            bottom: number;
        };
        objects: Array<any>;
        nodes: Array<any>;
        populate(group:Phaser.Group): void;
        populateHandler(sprite:Phaser.Sprite): void;
        split(): void;
        insert(body: Object): void;
        getIndex(rect: Object): number;
        retrieve(sprite: Object): Array<any>;
        clear(): void;
    }

    class Line {
        constructor(x1?: number, y1?: number, x2?: number, y2?: number);
        start: Phaser.Point;
        end: Phaser.Point;
        setTo(x1?: number, y1?: number, x2?: number, y2?: number): Phaser.Line;
        fromSprite(startSprite: Phaser.Sprite, endSprite: Phaser.Sprite, useCenter: boolean): Phaser.Line;
        intersects(line: Phaser.Line, asSegment?: boolean, result?: Phaser.Point): Phaser.Point;
        pointOnLine(x: number, y: number): boolean;
        pointOnSegment(x: number, y: number): boolean;
        length: number;
        angle: number;
        slope: number;
        perpSlope: number;
        static intersectsPoints(a: Phaser.Point, b: Phaser.Point, e: Phaser.Point, f: Phaser.Point, asSegment?: boolean, result?: Phaser.Point): Phaser.Point;
        static intersects(a: Phaser.Line, b: Phaser.Line, asSegment?: boolean, result?: Phaser.Point): Phaser.Point;
    }

    class Circle {
        constructor(x?: number, y?: number, diameter?: number);
        x: number;
        y: number;
        diameter: number;
        radius: number;
        left: number;
        right: number;
        top: number;
        bottom: number;
        area: number;
        empty: boolean;
        circumference(): number;
        setTo(x: number, y: number, diameter: number): Circle;
        copyFrom(source: any): Circle;
        copyTo(dest: Object): Object;
        distance(dest: Object, round: boolean): number;
        clone(out: Phaser.Circle): Phaser.Circle;
        contains(x: number, y: number): Phaser.Circle;
        circumferencePoint(angle: number, asDegrees: number, output?: Phaser.Point): Phaser.Point;
        offset(dx: number, dy: number): Phaser.Circle;
        offsetPoint(point: Phaser.Point): Phaser.Circle;
        toString(): string;
        static contains(a: Phaser.Circle, x: number, y: number): boolean;
        static equals(a: Phaser.Circle, b: Phaser.Circle): boolean;
        static intersects(a: Phaser.Circle, b: Phaser.Circle): boolean;
        static circumferencePoint(a: Phaser.Circle, angle: number, asDegrees: boolean, output?: Phaser.Point): Phaser.Point;
        static intersectsRectangle(c: Phaser.Circle, r: Phaser.Rectangle): boolean;
    }

    class Point {
        constructor(x: number, y: number);
        x: number;
        y: number;
        copyFrom(source: any): Phaser.Point;
        invert(): Phaser.Point;
        setTo(x: number, y: number): Phaser.Point;
        add(x: number, y: number): Phaser.Point;
        subtract(x: number, y: number): Phaser.Point;
        multiply(x: number, y: number): Phaser.Point;
        divide(x: number, y: number): Phaser.Point;
        clampX(min: number, max: number): Phaser.Point;
        clampY(min: number, max: number): Phaser.Point;
        clamp(min: number, max: number): Phaser.Point;
        clone(output: Phaser.Point): Phaser.Point;
        copyTo(dest: any): Object;
        distance(dest: Object, round?: boolean): number;
        equals(a: Phaser.Point): boolean;
        rotate(x: number, y: number, angle: number, asDegrees: boolean, distance: number): Phaser.Point;
        toString(): string;
        static add(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
        static subtract(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
        static multiply(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
        static divide(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
        static equals(a: Phaser.Point, b: Phaser.Point): boolean;
        static distance(a: Phaser.Point, b: Phaser.Point, round?: boolean): number;
        static rotate(a: Phaser.Point, x: number, y: number, angle: number, asDegrees: boolean, distance: boolean): Phaser.Point;
    }

    class Rectangle {
        constructor(x: number, y: number, width: number, height: number);
        x: number;
        y: number;
        width: number;
        height: number;
        halfWidth: number;
        halfHeight: number;
        bottom: number;
        bottomRight: Phaser.Point;
        left: number;
        right: number;
        volume: number;
        perimeter: number;
        centerX: number;
        centerY: number;
        top: number;
        topLeft: Phaser.Point;
        empty: boolean;
        offset(dx: number, dy: number): Phaser.Rectangle;
        offsetPoint(point: Phaser.Point): Phaser.Rectangle;
        setTo(x: number, y: number, width: number, height: number): Phaser.Rectangle;
        floor(): void;
        copyFrom(source: any): Phaser.Rectangle;
        copyTo(dest: any): Object;
        inflate(dx: number, dy: number): Phaser.Rectangle;
        size(output: Phaser.Point): Phaser.Point;
        clone(output: Phaser.Rectangle): Phaser.Rectangle;
        contains(x: number, y: number): boolean;
        containsRect(b: Phaser.Rectangle): boolean;
        equals(b: Phaser.Rectangle): boolean;
        intersection(b: Phaser.Rectangle, out: Phaser.Rectangle): Phaser.Rectangle;
        intersects(b: Phaser.Rectangle, tolerance: number): boolean;
        intersectsRaw(left: number, right: number, top: number, bottom: number, tolerance: number): boolean;
        union(b: Phaser.Rectangle, out: Phaser.Rectangle): Phaser.Rectangle;
        toString(): string;
        static inflate(a: Phaser.Rectangle, dx: number, dy: number): Phaser.Rectangle;
        static inflatePoint(a: Phaser.Rectangle, point: Phaser.Point): Phaser.Rectangle;
        static size(a: Phaser.Rectangle, output: Phaser.Point): Phaser.Point;
        static clone(a: Phaser.Rectangle, output: Phaser.Rectangle): Phaser.Rectangle;
        static contains(a: Phaser.Rectangle, x: number, y: number): boolean;
        static containsPoint(a: Phaser.Rectangle, point: Phaser.Point): boolean;
        static containsRect(a: Phaser.Rectangle, b: Phaser.Rectangle): boolean;
        static equals(a: Phaser.Rectangle, b: Phaser.Rectangle): boolean;
        static intersection(a: Phaser.Rectangle, b: Phaser.Rectangle, out: Phaser.Rectangle): Phaser.Rectangle;
        static intersects(a: Phaser.Rectangle, b: Phaser.Rectangle, tolerance: number): boolean;
        static intersectsRaw(a: Phaser.Rectangle, left: number, right: number, top: number, bottom: number, tolerance: number): boolean;
        static union(a: Phaser.Rectangle, b: Phaser.Rectangle, out: Phaser.Rectangle): Phaser.Rectangle;
    }

    class Net {
        constructor(game: Phaser.Game);
        game: Phaser.Game;
        getHostName(): string;
        checkDomainName(domain: string): string;
        updateQueryString(key: string, value: any, redirect?: boolean, url?: string): string;
        getQueryString(parameter?: string): string;
        decodeURI(value: string): string;
    }

    class TweenManager {
        constructor(game: Phaser.Game);
        game: Phaser.Game;
        getAll(): Phaser.Tween[];
        removeAll(): void;
        add(tween: Phaser.Tween): Phaser.Tween;
        create(object: Object): Phaser.Tween;
        remove(tween: Phaser.Tween): void;
        update(): boolean;
        pauseAll(): void;
        resumeAll(): void;
    }

    class Tween {
        constructor(object: Object, game: Phaser.Game);
        game: Phaser.Game;
        pending: boolean;
        pendingDelete: boolean;
        onStart: Phaser.Signal;
        onComplete: Phaser.Signal;
        isRunning: boolean;
        to(properties: Object, duration?: number, ease?: any, autoStart?: boolean, delay?: number, loop?: boolean): Phaser.Tween;
        start(time: number): Phaser.Tween;
        stop(): Phaser.Tween;
        delay(amount: number): Phaser.Tween;
        repeat(times: number): Phaser.Tween;
        yoyo(yoyo: boolean): Phaser.Tween;
        easing(easing: any): Phaser.Tween;
        interpolation(interpolation: Function): Phaser.Tween;
        chain(...tweens: Phaser.Tween[]): Phaser.Tween;
        loop(): Phaser.Tween;
        onStartCallback(callback: Function): Phaser.Tween;
        onUpdateCallback(callback: Function): Phaser.Tween;
        onCompleteCallback(callback: Function): Phaser.Tween;
        pause(): void;
        resume(): void;
        update(time: number): boolean;
    }

    module Easing {

        class Linear {
            static None(k: number): number;
        }

        class Quadratic {
            static In(k: number): number;
            static Out(k: number): number;
            static InOut(k: number): number;
        }

        class Cubic {
            static In(k: number): number;
            static Out(k: number): number;
            static InOut(k: number): number;
        }

        class Quartic {
            static In(k: number): number;
            static Out(k: number): number;
            static InOut(k: number): number;
        }

        class Quintic {
            static In(k: number): number;
            static Out(k: number): number;
            static InOut(k: number): number;
        }

        class Sinusoidal {
            static In(k: number): number;
            static Out(k: number): number;
            static InOut(k: number): number;
        }

        class Exponential {
            static In(k: number): number;
            static Out(k: number): number;
            static InOut(k: number): number;
        }

        class Circular {
            static In(k: number): number;
            static Out(k: number): number;
            static InOut(k: number): number;
        }

        class Elastic {
            static In(k: number): number;
            static Out(k: number): number;
            static InOut(k: number): number;
        }

        class Back {
            static In(k: number): number;
            static Out(k: number): number;
            static InOut(k: number): number;
        }

        class Bounce {
            static In(k: number): number;
            static Out(k: number): number;
            static InOut(k: number): number;
        }

    }

    class Time {
        constructor(game: Phaser.Game);
        game: Phaser.Game;
        physicsElapsed: number;
        time: number;
        pausedTime: number;
        now: number;
        elapsed: number;
        fps: number;
        fpsMin: number;
        fpsMax: number;
        msMin: number;
        msMax: number;
        frames: number;
        pauseDuration: number;
        timeToCall: number;
        lastTime: number;
        events: Phaser.Timer;
        create(autoDestroy: boolean): Phaser.Timer;
        removeAll(): void;
        update(time: number): void;
        gamePaused(): void;
        gameResumed(): void;
        totalElapsedSeconds(): number;
        elapsedSince(since: number): number;
        elapsedSecondsSince(since: number): number;
        reset(): void;
    }

    class Timer {
        constructor(game: Phaser.Game, autoDestroy: boolean);
        game: Phaser.Game;
        running: boolean;
        autoDestroy: boolean;
        expired: boolean;
        events: Phaser.TimerEvent[];
        onComplete: Phaser.Signal;
        nextTick: number;
        paused: boolean;
        static MINUTE: number;
        static SECOND: number;
        static HALF: number;
        static QUARTER: number;
        add(delay: number, callback: any, callbackContext: any, ...args: any[]): Phaser.TimerEvent;
        repeat(delay: number, repeatCount: number, callback: any, callbackContext: any, ...args: any[]): Phaser.TimerEvent;
        loop(delay: number, callback: any, callbackContext: any, ...args: any[]): Phaser.TimerEvent;
        start(): void;
        stop(): void;
        remove(event: Phaser.TimerEvent): boolean;
        order():void;
        sortHandler():number;
        update(time: number): boolean;
        pause(): void;
        resume(): void;
        destroy(): void;
        next: number;
        duration: number;
        length: number;
        ms: number;
        seconds: number;
    }

    class TimerEvent {
        constructor(timer: Phaser.Timer, delay: number, tick: number, repeatCount: number, loop: boolean, callback: any, callbackContext, any, args:any[]);
        timer: Phaser.Timer;
        delay: number;
        tick: number;
        repeatCount: number;
        loop: boolean;
        callback: any;
        callbackContext: any;
        args: any[];
    }

    class AnimationManager {
        constructor(sprite);
        sprite: Phaser.Sprite;
        game: Phaser.Game;
        currentFrame: Phaser.Frame;
        updateIfVisible: boolean;
        frameData: Phaser.FrameData;
        frameTotal: number;
        frame: number;
        frameName: string;
        loadFrameData(frameData: Phaser.FrameData): void;
        add(name: string, frames?: Array<any>, frameRate?: number, loop?: boolean, useNumericIndex?: boolean): Phaser.Animation;
        getAnimation(name: string): Phaser.Animation;
        validateFrames(frames: Array<any>, useNumericIndex?: boolean): boolean;
        play(name: string, frameRate?: number, loop?: boolean): Phaser.Animation;
        stop(name?: string, resetFrame?: boolean): void;
        update(): boolean;
        destroy(): void;
    }

    class Animation {
        constructor(game: Phaser.Game, parent: Phaser.Sprite, name: string, frameData: Phaser.FrameData, frames: any[], delay: number, looped: boolean);
        game: Phaser.Game;
        name: string;
        delay: number;
        looped: boolean;
        isFinished: boolean;
        isPlaying: boolean;
        currentFrame: Phaser.Frame;
        frameTotal: number;
        frame: number;
        play(frameRate?: number, loop?: boolean): Phaser.Animation;
        restart(): void;
        stop(resetFrame?: boolean): void;
        update(): boolean;
        destroy(): void;
        onComplete(): void;
    }

    class Frame {
        constructor(index: number, x: number, y: number, width: number, height: number, name: string, uuid: string);
        index: number;
        x: number;
        y: number;
        width: number;
        height: number;
        centerX: number;
        centerY: number;
        distance: number;
        name: string;
        uuid: string;
        rotated: boolean;
        rotationDirection: string;
        trimmed: boolean;
        sourceSizeW: number;
        sourceSizeH: number;
        spriteSourceSizeX: number;
        spriteSourceSizeY: number;
        spriteSourceSizeW: number;
        spriteSourcesizeH: number;
        setTrim(trimmed: boolean, actualWidth: number, actualHeight: number, destX: number, destY: number, destWidth: number, destHeight: number): void;
    }

    class FrameData {
        addFrame(frame: Frame): Frame;
        getFrame(index: number): Frame;
        getFrameByName(name: string): Frame;
        checkFrame(name: string): boolean;
        getFrameRange(start: number, end: number, output: Array<Frame>): Array<Frame>;
        getFrames(frames: Array<number>, useNumericIndex?: boolean, output?: Array<Frame>): Array<Frame>;
        getFrameIndexes(frames: Array<number>, useNumericIndex?: boolean, output?: Array<number>): Array<number>;
        total: number;
    }

    class AnimationParser {
        spriteSheet(game: Phaser.Game, key: string, frameWidth: number, frameHeight: number, frameMax?: number): Phaser.FrameData;
        JSONData(game: Phaser.Game, json: Object, cacheKey: string): Phaser.FrameData;
        JSONDataHash(game: Phaser.Game, json: Object, cacheKey: string): Phaser.FrameData;
        XMLData(game: Phaser.Game, xml: Object, cacheKey: string): Phaser.FrameData;
    }

    class Cache {
        constructor(game: Phaser.Game);
        game: Phaser.Game;
        onSoundUnlock: Phaser.Signal;
        addCanvas(key: string, canvas: HTMLCanvasElement, context: CanvasRenderingContext2D): void;
        addRenderTexture(key: string, texture: RenderTexture): void;
        addSpriteSheet(key: string, url: string, data: Object, frameWidth: number, frameHeight: number, frameMax: number): void;
        addTilemap(key: string, url: string, data: Object, mapData: Object, atlasData: Object): void;
        addTextureAtlas(key: string, url: string, data: Object, atlasData: Object): void;
        addBitmapFont(key: string, url: string, data: Object, xmlData: Object): void;
        addDefaultImage(): void;
        addImage(key: string, url: string, data: Object): void;
        addSound(key: string, url: string, data: Object): void;
        reloadSound(key: string): void;
        reloadSoundComplete(key: string): void;
        updateSound(key: string, property: string, value: Phaser.Sound): void;
        decodedSound(key: string, data: Object): void;
        addText(key: string, url: string, data: Object): void;
        getCanvas(key: string): Object;
        checkImageKey(key: string): boolean;
        getImage(key: string): Object;
        getTilemap(key: string): Phaser.Tilemap;
        getFrameData(key: string): Phaser.FrameData;
        getFrameByIndex(key: string, frame: string): Phaser.Frame;
        getFrameByName(key: string, frame: string): Phaser.Frame;
        getFrame(key: string): Phaser.Frame;
        getTextureFrame(key: string): Phaser.Frame;
        getTexture(key: string): Phaser.RenderTexture;
        getSound(key: string): Phaser.Sound;
        getSoundData(key: string): Object;
        isSoundDecoded(key: string): boolean;
        isSoundReady(key: string): boolean;
        isSpriteSheet(key: string): boolean;
        getText(key: string): Object;
        getKeys(array: Array<string>): Array<string>;
        getImageKeys(): string[];
        getSoundKeys(): string[];
        getTextKeys(): string[];
        removeCanvas(key: string): void;
        removeImage(key: string): void;
        removeSound(key: string): void;
        removeText(key: string): void;
        destroy(): void;
    }

    class Loader {
        static TEXTURE_ATLAS_JSON_ARRAY: number;
        static TEXTURE_ATLAS_JSON_HASH: number;
        static TEXTURE_ATLAS_XML_STARLING: number;
        constructor(game: Phaser.Game);
        game: Phaser.Game;
        queueSize: number;
        isLoading: boolean;
        hasLoaded: boolean;
        progress: number;
        preloadSprite: Phaser.Sprite;
        crossOrigin: string;
        baseURL: string;
        onFileComplete: Phaser.Signal;
        onFileError: Phaser.Signal;
        onLoadStart: Phaser.Signal;
        onLoadComplete: Phaser.Signal;
        setPreloadSprite(sprite: Phaser.Sprite, direction?: number): void;
        checkKeyExists(type: string, key: string): boolean;
        reset(): void;
        addToFileList(type: string, key: string, url: string, properties: Array<any>): void;
        image(key: string, url: string, overwrite?: boolean): void;
        text(key: string, url: string, overwrite?: boolean): void;
        spritesheet(key: string, url: string, frameWidth: number, frameHeight: number, frameMax: number): void;
        audio(key: string, urls: any, autoDecode?: boolean): void;
        tilemap(key: string, tilesetURL: string, mapDataURL?: string, mapData?: Object, format?: string): void;
        tileset(key: string, url: string, tileWidth: number, tileHeight: number, tileMargin?: number, tileSpacing?: number, rows?: number, columns?: number, limit?: number): void;
        bitmapFont(key: string, textureURL: string, xmlURL?: string, xmlData?: Object): void;
        atlasJSONArray(key: string, textureURL: string, atlasURL?: string, atlasData?: Object): void;
        atlasJSONHash(key: string, textureURL: string, atlasURL?: string, atlasData?: Object): void;
        atlasXML(key: string, textureURL: string, atlasURL?: string, atlasData?: Object): void;
        atlas(key: string, textureURL: string, atlasURL?: string, atlasData?: Object, format?: number): void;
        removeFile(key: string): void;
        removeAll(): void;
        start(): void;
        loadFile(): void;
        getAudioURL(urls: string[]): string;
        fileError(key: string): void;
        fileComplete(key: string): void;
        jsonLoadComplete(key: string): void;
        csvLoadComplete(key: string): void;
        dataLoadError(key: string): void;
        xmlLoadComplete(key: string): void;
        nextFile(previousKey: string, success: boolean): void;
    }

    class LoaderParser {
        bitmapFont(game: Phaser.Game, xml: Object, cacheKey: Phaser.FrameData): void;
    }

    class Sound {
        constructor(game: Phaser.Game, key: string, volume?: number, loop?: boolean);
        game: Phaser.Game;
        name: string;
        key: string;
        loop: boolean;
        markers: Object;
        context: any;
        autoplay: boolean;
        totalDuration: number;
        startTime: number;
        currentTime: number;
        duration: number;
        stopTime: number;
        paused: boolean;
        isPlaying: boolean;
        currentMarker: string;
        pendingPlayback: boolean;
        override: boolean;
        usingWebAudio: boolean;
        usingAudioTag: boolean;
        onDecoded: Phaser.Signal;
        onPlay: Phaser.Signal;
        onPause: Phaser.Signal;
        onResume: Phaser.Signal;
        onLoop: Phaser.Signal;
        onStop: Phaser.Signal;
        onMute: Phaser.Signal;
        isDecoded: boolean;
        isDecoding: boolean;
        mute: boolean;
        volume: number;
        onMarkerComplete: Phaser.Signal;
        soundHasUnlocked(key: string): void;
        addMarker(name: string, start: number, stop: number, volume?: number, loop?: boolean): void;
        removeMarker(name: string): void;
        update(): void;
        play(marker?: string, position?: number, volume?: number, loop?: boolean): Phaser.Sound;
        restart(marker: string, position: number, volume?: number, loop?: boolean): void;
        pause(): void;
        resume(): void;
        stop(): void;
    }

    class SoundManager {
        constructor(game: Phaser.Game);
        game: Phaser.Game;
        onSoundDecode: Phaser.Signal;
        context: any;
        usingWebAudio: boolean;
        usingAudioTag: boolean;
        noAudio: boolean;
        touchLocked: boolean;
        channels: number;
        mute: boolean;
        volume: number;
        boot(): void;
        unlock(): void;
        stopAll(): void;
        pauseAll(): void;
        resumeAll(): void;
        decode(key: string, sound?: Phaser.Sound): void;
        update(): void;
        add(key: string, volume: number, loop: boolean): Phaser.Sound;
    }

    module Utils {
        class Debug {
            constructor(game: Phaser.Game);
            game: Phaser.Game;
            font: string;
            lineHeight: number;
            renderShadow: boolean;
            currentX: number;
            currentY: number;
            currentAlpha: number;
            start(x?: number, y?: number, color?: string): void;
            stop(): void;
            line(text: string, x: number, y: number): void;
            renderQuadTree(quadtree: Phaser.QuadTree, color?: string): void;
            renderSpriteCorners(sprite: Phaser.Sprite, showText?: boolean, showBounds?: boolean, color?: string): void;
            renderSoundInfo(sound: Phaser.Sound, x: number, y: number, color?: string): void;
            renderCameraInfo(camera: Phaser.Camera, x: number, y: number, color?: string): void;
            renderPointer(pointer: Phaser.Pointer, hideIfUp?: boolean, downColor?: string, upColor?: string, color?: string): void;
            renderSpriteInputInfo(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
            renderSpriteCollision(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
            renderInputInfo(x: number, y: number, color?: string): void;
            renderSpriteInfo(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
            renderWorldTransformInfo(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
            renderLocalTransformInfo(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
            renderPointInfo(point: Phaser.Point, x: number, y: number, color?: string): void;
            renderSpriteBody(sprite: Phaser.Sprite, color?: string): void;
            renderSpriteBounds(sprite: Phaser.Sprite, color?: string, fill?: boolean): void;
            renderPixel(x: number, y: number, fillStyle?: string): void;
            renderPoint(point: Phaser.Point, fillStyle?: string): void;
            renderRectangle(rect: Phaser.Rectangle, fillStyle?: string): void;
            renderCircle(circle: Phaser.Circle, fillStyle?: string): void;
            renderText(text: string, x: number, y: number, color?: string, font?: string): void;
        }
    }

    class Color {
        getColor32(alpha: number, red: number, green: number, blue: number): number;
        getColor(red: number, green: number, blue: number): number;
        hexToRGB(h: string): number;
        getColorInfo(color: number): string;
        RGBtoHexstring(color: number): string;
        RGBtoWebstring(color: number): string;
        colorToHexstring(color: number): string;
        interpolateColor(color1: number, color2: number, steps: number, currentStep: number, alpha: number): number;
        interpolateColorWithRGB(color: number, r: number, g: number, b: number, steps: number, currentStep: number): number;
        interpolateRGB(r1: number, g1: number, b1: number, r2: number, g2: number, b2: number, steps: number, currentStep: number): number;
        getRandomColor(min?: number, max?: number, alpha?: number): number;
        getRGB(color: number): Object;
        getWebRGB(color: number): string;
        getAlpha(color: number): number;
        getAlphaFloat(color: number): number;
        getRed(color: number): number;
        getGreen(color: number): number;
        getBlue(color: number): number;
    }

    module Physics {
        class Arcade {
            constructor(game: Phaser.Game)
            game: Phaser.Game;
            gravity: Phaser.Point;
            worldLeft: SAT.Box;
            worldRight: SAT.Box;
            worldTop: SAT.Box;
            worldBottom: SAT.Box;
            worldPolys: any;
            quadTree: Phaser.QuadTree;
            maxObjects: number;
            maxLevels: number;
            RECT: number;
            CIRCLE: number;
            POLYGON: number;
            checkBounds(body: Phaser.Physics.Arcade.Body): boolean;
            setBoundsToWorld(left: boolean, right: boolean, top: boolean, bottom: boolean): void;
            setBounds(x: number, y: number, width: number, height: number, left: boolean, right: boolean, top: boolean, bottom: boolean): void;
            updateMotion(body: Phaser.Physics.Arcade.Body): Phaser.Point;
            overlap(object1: any, object2: any, overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
            collide(object1: any, object2: any, collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
            collideHandler(object1: any, object2: any, collideCallback: Function, processCallback: Function, callbackContext: any, overlapOnly: boolean): boolean;
            collideSpriteVsSprite(sprite1: Phaser.Sprite, sprite2: Phaser.Sprite,  collideCallback: Function, processCallback: Function, callbackContext: any, overlapOnly: boolean): boolean;
            collideSpriteVsGroup(sprite1: Phaser.Sprite, group: Phaser.Group,  collideCallback: Function, processCallback: Function, callbackContext: any, overlapOnly: boolean): boolean;
            collideGroupVsSelf(group: Phaser.Group,  collideCallback: Function, processCallback: Function, callbackContext: any, overlapOnly: boolean): boolean;
            collideGroupVsGroup(group: Phaser.Group, group2: Phaser.Group,  collideCallback: Function, processCallback: Function, callbackContext: any, overlapOnly: boolean): boolean;
            collideSpriteVsTilemapLayer(sprite: Phaser.Sprite, tilemapLayer: Phaser.TilemapLayer,  collideCallback: Function, processCallback: Function, callbackContext: any): boolean;
            collideGroupVsTilemapLayer(group: Phaser.Group, tilemapLayer: Phaser.TilemapLayer,  collideCallback: Function, processCallback: Function, callbackContext: any): boolean;
            separate(body: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body, processCallback: Function, callbackContext: any, overlapOnly: boolean): boolean;
            intersects(a: Phaser.Physics.Arcade.Body, b: Phaser.Physics.Arcade.Body): boolean;
            tileIntersects(body: Phaser.Physics.Arcade.Body, tile: Phaser.Tile): boolean;
            separateTiles(body: Phaser.Physics.Arcade.Body, tile: Array<Phaser.Tile>): boolean;
            separateTile(body: Phaser.Physics.Arcade.Body, tile: Phaser.Tile): boolean;
            processTileSeparation(body: Phaser.Physics.Arcade.Body): boolean;
            moveToObject(displayObject: Phaser.Sprite, destination: Phaser.Sprite, speed?: number, maxTime?: number): number;
            moveToPointer(displayObject: Phaser.Sprite, speed?: number, pointer?: Phaser.Pointer, maxTime?: number): number;
            moveToXY(displayObject: Phaser.Sprite, x: number, y: number, speed?: number, maxTime?: number): number;
            velocityFromAngle(angle: number, speed?: number, point?: Phaser.Point): Phaser.Point;
            velocityFromRotation(rotation: number, speed?: number, point?: Phaser.Point): Phaser.Point;
            accelerationFromRotation(rotation: number, speed?: number, point?: Phaser.Point): Phaser.Point;
            accelerateToObject(displayObject: Phaser.Sprite, destination: Phaser.Sprite, speed?: number, xSpeedMax?: number, ySpeedMax?: number): number;
            accelerateToPointer(displayObject: Phaser.Sprite, pointer: Phaser.Pointer, speed?: number, xSpeedMax?: number, ySpeedMax?: number): number;
            accelerateToXY(displayObject: Phaser.Sprite, x: number, y: number, speed?: number, xSpeedMax?: number, ySpeedMax?: number): number;
            distanceTo(source: Phaser.Sprite, target: Phaser.Sprite): number;
            distanceToXY(displayObject: Phaser.Sprite, x: number, y: number): number;
            distanceToPointer(displayObject: Phaser.Sprite, pointer: Phaser.Pointer): number;
            angleBetween(source: Phaser.Sprite, target: Phaser.Sprite): number;
            angleToXY(displayObject: Phaser.Sprite, x: number, y: number): number;
            angleToPointer(displayObject: Phaser.Sprite, pointer: Phaser.Pointer): number;
        }

        module Arcade {

            class FaceChoices {
                none: boolean;
                any: boolean;
                up: boolean;
                down: boolean;
                left: boolean;
                right: boolean;
                x: number;
                y: number;
            }        

            class Body {
                constructor(sprite: Phaser.Sprite);
                sprite: Phaser.Sprite;
                game: Phaser.Game;
                offset: Phaser.Point;
                preX: number;
                preY: number;
                preRotation: number;
                velocity: Phaser.Point;
                acceleration: Phaser.Point;
                speed: number;
                angle: number;
                gravity: Phaser.Point;
                bounce: Phaser.Point;
                minVelocity: Phaser.Point;
                maxVelocity: Phaser.Point;
                angularVelocity: number;
                angularAcceleration: number;
                angularDrag: number;
                maxAngular: number;
                mass: number;
                linearDamping: number;
                checkCollision: FaceChoices;
                touching: FaceChoices;
                blocked: FaceChoices;
                facing: number;
                rebound: boolean;
                immovable: boolean;
                moves: boolean;
                rotation: number;
                allowRotation: boolean;
                allowGravity: boolean;
                customSeparateCallback: any;
                customSeparateContext: any;
                collideCallback: any;
                collideCallbackContext: any;
                collideWorldBounds: boolean;
                type: number;
                shape: any;
                polygon: any;
                left: number;
                right: number;
                top: number;
                bottom: number;
                width: number;
                height: number;
                contacts: any;
                overlapX: number;
                overlapY: number;
                updateScale(): void;
                preUpdate(): void;
                checkBlocked(): void;
                updateBounds(): void;
                applyDamping(): void;
                reboundCheck(x: number, y: number, rebound: boolean): void;
                getUpwardForce(): number;
                getDownwardForce(): number;
                sub(x: number): void;
                add(x: number): void;
                give(body: Phaser.Physics.Arcade.Body, response: SAT.Response): void;
                take(body: Phaser.Physics.Arcade.Body, response: SAT.Response): void;
                split(body: Phaser.Physics.Arcade.Body, response: SAT.Response): void;
                exchange(body: Phaser.Physics.Arcade.Body): void;
                processRebound(body: Phaser.Physics.Arcade.Body): void;
                overlap(body: Phaser.Physics.Arcade.Body, response: SAT.Response): boolean;
                inContact(body: Phaser.Physics.Arcade.Body): boolean;
                addContact(body: Phaser.Physics.Arcade.Body): boolean;
                removeContact(body: Phaser.Physics.Arcade.Body): boolean;
                separate(body: Phaser.Physics.Arcade.Body, response: SAT.Response): boolean;
                hitLeft(body: Phaser.Physics.Arcade.Body, response: SAT.Response): void;
                hitRight(body: Phaser.Physics.Arcade.Body, response: SAT.Response): void;
                hitTop(body: Phaser.Physics.Arcade.Body, response: SAT.Response): void;
                hitBottom(body: Phaser.Physics.Arcade.Body, response: SAT.Response): void;
                integrateVelocity():void;
                postUpdate(): void;
                reset(full: boolean): void;
                destroy(): void;
                setCircle(radius: number, offsetX: number, offsetY: number): void;
                setRectangle(width: number, height: number, translateX: number, translateY: number): void;
                setPoints(points: any): void;
                translate(x: number, y: number): void;
                onFloor(): boolean;
                onWall(): boolean;
                deltaX(): number;
                deltaY(): number;
                deltaZ(): number;
                x: number;
                y: number;
            }
        }
    }

    class Particles {
        constructor(game: Phaser.Game);
        emitters: Object;
        ID: number;
        add(emitter: Phaser.Particles.Arcade.Emitter): Phaser.Particles.Arcade.Emitter;
        remove(emitter: Phaser.Particles.Arcade.Emitter): void;
        update(): void;
    }

    module Particles {
        module Arcade {
            class Emitter extends Phaser.Group
            {
                constructor(game: Phaser.Game, x: number, y: number, maxParticles?: number);
                name: string;
                type: number;
                x: number;
                y: number;
                width: number;
                height: number;
                minParticleSpeed: Phaser.Point;
                maxParticleSpeed: Phaser.Point;
                minParticleScale: number;
                maxParticleScale: number;
                minRotation: number;
                maxRotation: number;
                gravity: number;
                particleClass: string;
                particleDrag: Phaser.Point;
                angularDrag: number;
                frequency: number;
                maxParticles: number;
                lifespan: number;
                bounce: Phaser.Point;
                on: boolean;
                exists: boolean;
                emitX: number;
                emitY: number;
                alpha: number;
                visible: boolean;
                left: number;
                top: number;
                bottom: number;
                right: number;
                update(): void;
                makeParticles(keys: string[], frames: string[], quantity: number, collide: boolean, collideWorldBounds: boolean): Phaser.Particles.Arcade.Emitter;
                kill(): void;
                revive(): void;
                start(explode: boolean, lifespan: number, frequency: number, quantity: number): void;
                emitParticle(): void;
                setSize(width: number, height: number): void;
                setXSpeed(min: number, max: number): void;
                setYSpeed(min: number, max: number): void;
                setRotation(min: number, max: number): void;
                at(object: Object): void;

            }
        }
    }

    class Tilemap {
        constructor(game: Phaser.Game, key: string, x: number, y: number, resizeWorld?: boolean, tileWidth?: number, tileHeight?: number);
        game: Phaser.Game;
        group: Phaser.Group;
        name: string;
        key: string;
        renderOrderID: number;
        collisionCallback: Function;
        exists: boolean;
        visible: boolean;
        tiles: Array<any>;
        layers: Array<TilemapLayer>;
        position: Phaser.Point;
        type: number;
        renderer: Phaser.TilemapRenderer;
        mapFormat: string;
        widthInPixels: number;
        heightInPixels: number;
        static CSV: number;
        static JSON: number;
        parseCSV(data: string, key: string, tileWidth: number, tileHeight: number): void;
        parseTiledJSON(json: string, key: string): void;
        generateTiles(quantity: number): void;
        setCollisionCallback(context: Object, callback: Function): void;
        setCollisionRange(start: number, end: number, collision: number, resetCollisions?: boolean, separateX?: boolean, separateY?: boolean): void;
        setCollisionByIndex(value: number[], collision: number, resetCollisions?: boolean, separateX?: boolean, separateY?: boolean): void;
        getTileByIndex(value: number): Tile;
        getTile(x: number, y: number, layer?: number): Tile;
        getTileFromWorldXY(x: number, y: number, layer?: number): Tile;
        getTileFromInputXY(layer?: number): Tile;
        getTileOverlaps(object: Object): Array<any>;
        collide(objectOrGroup: any, callback: Function, context: Object): boolean;
        collideGameObject(object: Object): boolean;
        putTile(x: number, y: number, index: number, layer?: number): void;
        update(): void;
        destroy(): void;
    }

    class TilemapLayer {
        constructor(game:Phaser.Game, tilemap:Phaser.Tilemap, index:number, width:number, height:number);
        //constructor(parent: Tilemap, id: number, key: string, mapFormat: number, name: string, tileWidth: number, tileHeight: number);
        exists: boolean;
        visible: boolean;
        widthInTiles: number;
        heightInTiles: number;
        widthInPixels: number;
        heightInPixels: number;
        tileMargin: number;
        tileSpacing: number;
        parent: Tilemap;
        game: Phaser.Game;
        ID: number;
        name: string;
        key: string;
        type: number;
        mapFormat: number;
        tileWidth: number;
        tileHeight: number;
        boundsInTiles: Phaser.Rectangle;
        tileset: Object;
        canvas: any;
        context: any;
        baseTexture: any;
        texture: any;
        sprite: Phaser.Sprite;
        mapData: Array<any>;
        alpha: number;
        putTileWorldXY(x: number, y: number, index: number): void;
        putTile(x: number, y: number, index: number): void;
        swapTile(tileA: number, tileB: number, x?: number, y?: number, width?: number, height?: number): void;
        fillTile(index: number, x?: number, y?: number, width?: number, height?: number): void;
        randomiseTiles(tiles: number[], x?: number, y?: number, width?: number, height?: number): void;
        replaceTile(tileA: number, tileB: number, x?: number, y?: number, width?: number, height?: number): void;
        getTileBlock(x: number, y: number, width: number, height: number): Array<Tile>;
        getTileFromWorldXY(x: number, y: number): Tile;
        getTileOverlaps(object: Object): Array<Tile>;
        getTempBlock(x: number, y: number, width: number, height: number, collisionOnly?: boolean): void;
        getTileIndex(x: number, y: number): number;
        addColumn(column: string[]): void;
        createCanvas(): void;
        updateBounds(): void;
        parseTileOffsets(): number;
    }

    class Tile {
        constructor(game: Phaser.Game, tilemap: Tilemap, index: number, width: number, height: number);
        mass: number;
        collideNone: boolean;
        collideLeft: boolean;
        collideRight: boolean;
        collideUp: boolean;
        collideDown: boolean;
        separateX: boolean;
        separateY: boolean;
        game: Phaser.Game;
        tilemap: Tilemap;
        index: number;
        width: number;
        height: number;
        destroy(): void;
        setCollision(left: boolean, right: boolean, up: boolean, down: boolean, reset: boolean, seperateX: boolean, seperateY: boolean): void;
        resetCollsion(): void;
        toString(): string;
    }

    class Tileset {
        constructor(name: string, firstgid: number, width: number, height: number, margin: number, spacing: number, properties: any);
        name: string;
        firstgid: number;
        tileWidth: number;
        tileHeight: number;
        tileMargin: number;
        tileSpacing: number;
        properties: any;
        image: any;
        rows: number;
        setSpacing(margin: number, spacing: number);
    }

}