/// /// // Type definitions for Phaser 2.6.2 - 26th August 2016 // Project: https://github.com/photonstorm/phaser declare module "phaser" { export = Phaser; } declare class Phaser { static VERSION: string; static DEV_VERSION: string; static GAMES: Phaser.Game[]; static AUTO: number; static CANVAS: number; static WEBGL: number; static HEADLESS: number; static BITMAPDATA: number; static BITMAPTEXT: number; static BUTTON: number; static CANVAS_FILTER: number; static CIRCLE: number; static ELLIPSE: number; static EMITTER: number; static GRAPHICS: number; static GROUP: number; static IMAGE: number; static LINE: number; static MATRIX: number; static POINT: number; static POINTER: number; static POLYGON: number; static RECTANGLE: number; static ROUNDEDRECTANGLE: number; static RENDERTEXTURE: number; static RETROFONT: number; static SPRITE: number; static SPRITEBATCH: number; static TEXT: number; static TILEMAP: number; static TILEMAPLAYER: number; static TILESPRITE: number; static WEBGL_FILTER: number; static ROPE: number; static CREATURE: number; static VIDEO: number; static NONE: number; static LEFT: number; static RIGHT: number; static UP: number; static DOWN: number; static HORIZONTAL: number; static VERTICAL: number; static LANDSCAPE: number; static PORTRAIT: number; static ANGLE_UP: number; static ANGLE_DOWN: number; static ANGLE_LEFT: number; static ANGLE_RIGHT: number; static ANGLE_NORTH_EAST: number; static ANGLE_NORTH_WEST: number; static ANGLE_SOUTH_EAST: number; static ANGLE_SOUTH_WEST: number; static TOP_LEFT: number; static TOP_CENTER: number; static TOP_RIGHT: number; static LEFT_TOP: number; static LEFT_CENTER: number; static LEFT_BOTTOM: number; static CENTER: number; static RIGHT_TOP: number; static RIGHT_CENTER: number; static RIGHT_BOTTOM: number; static BOTTOM_LEFT: number; static BOTTOM_CENTER: number; static BOTTOM_RIGHT: number; } declare module Phaser { class Animation { constructor(game: Phaser.Game, parent: Phaser.Sprite, name: string, frameData: Phaser.FrameData, frames: number[] | string[], frameRate?: number, loop?: boolean); currentFrame: Phaser.Frame; delay: number; enableUpdate: boolean; frame: number; frameTotal: number; game: Phaser.Game; isFinished: boolean; isPaused: boolean; isPlaying: boolean; killOnComplete: boolean; loop: boolean; loopCount: number; name: string; onComplete: Phaser.Signal; onLoop: Phaser.Signal; onStart: Phaser.Signal; onUpdate: Phaser.Signal; paused: boolean; reversed: boolean; speed: number; complete(): void; destroy(): void; static generateFrameNames(prefix: string, start: number, stop: number, suffix?: string, zeroPad?: number): string[]; next(quantity?: number): void; onPause(): void; onResume(): void; play(frameRate?: number, loop?: boolean, killOnComplete?: boolean): Phaser.Animation; previous(quantity?: number): void; restart(): void; reverse(): Animation; reverseOnce(): Animation; setFrame(frameId?: string | number, useLocalFrameIndex?: boolean): void; stop(resetFrame?: boolean, dispatchComplete?: boolean): void; update(): boolean; updateCurrentFrame(signalUpdate: boolean, fromPlay?: boolean): boolean; updateFrameData(frameData: FrameData): void; } class AnimationManager { constructor(sprite: Phaser.Sprite); currentAnim: Phaser.Animation; currentFrame: Phaser.Frame; frame: number; frameData: Phaser.FrameData; frameName: string; frameTotal: number; game: Phaser.Game; isLoaded: boolean; name: string; paused: boolean; sprite: Phaser.Sprite; updateIfVisible: boolean; add(name: string, frames?: number[] | string[], frameRate?: number, loop?: boolean, useNumericIndex?: boolean): Phaser.Animation; copyFrameData(frameData: Phaser.FrameData, frame: string | number): boolean; destroy(): void; getAnimation(name: string): Phaser.Animation; next(quantity?: number): void; play(name: string, frameRate?: number, loop?: boolean, killOnComplete?: boolean): Phaser.Animation; previous(quantity?: number): void; stop(name?: string, resetFrame?: boolean): void; update(): boolean; validateFrames(frames: Phaser.Frame[], useNumericIndex?: boolean): boolean; } class AnimationParser { static JSONData(game: Phaser.Game, json: any): Phaser.FrameData; static JSONDataHash(game: Phaser.Game, json: any): Phaser.FrameData; static JSONDataPyxel(game: Phaser.Game, json: any): Phaser.FrameData; static spriteSheet(game: Phaser.Game, key: string, frameWidth: number, frameHeight: number, frameMax?: number, margin?: number, spacing?: number): Phaser.FrameData; static XMLData(game: Phaser.Game, xml: any): Phaser.FrameData; } class AudioSprite { constructor(game: Phaser.Game, key: string); game: Phaser.Game; key: string; config: any; autoplayKey: string; autoplay: boolean; sounds: any; get(marker: string): Phaser.Sound; play(marker: string, volume?: number): Phaser.Sound; stop(marker: string): Phaser.Sound; } class ArraySet { constructor(list: any[]); position: number; list: any[]; total: number; first: any; next: any; add(item: any): any; getByKey(property: string, value: any): any; getIndex(item: any): number; exists(item: any): boolean; reset(): void; remove(item: any): any; removeAll(destoy?: boolean): void; setAll(key: any, value: any): void; callAll(key: string, ...parameter: any[]): void; } class ArrayUtils { static getRandomItem(objects: T[], startIndex?: number, length?: number): T; static removeRandomItem(objects: T[], startIndex?: number, length?: number): T; static shuffle(array: T[]): T[]; static transposeMatrix(array: T[]): T; static rotateMatrix(matrix: any, direction: number | string): any; static findClosest(value: number, arr: number[]): number; static rotate(array: any[]): any; static rotateLeft(array: any[]): any; static rotateRight(array: any[]): any; static numberArray(start: number, end: number): number[]; static numberArrayStep(start: number, end?: number, step?: number): number[]; } interface BitmapFont { base: PIXI.BaseTexture; data: HTMLImageElement; font: Phaser.BMFont; url: string; } interface BMFont { chars: Phaser.BMFontChar[]; font: string; lineHeight: number; size: number; } interface BMFontChar { x: number; y: number; width: number; height: number; xOffset: number; yOffset: number; xAdvance: number; kerning: number[]; texture: PIXI.BaseTexture; } class BitmapData { constructor(game: Phaser.Game, key: string, width?: number, height?: number, skipPool?: boolean); baseTexture: PIXI.BaseTexture; buffer: ArrayBuffer; canvas: HTMLCanvasElement; context: CanvasRenderingContext2D; ctx: CanvasRenderingContext2D; data: Uint8Array; dirty: boolean; disableTextureUpload: boolean; game: Phaser.Game; height: number; imageData: ImageData; key: string; op: string; pixels: Uint32Array; smoothed: boolean; smoothProperty: string; texture: PIXI.Texture; textureFrame: Phaser.Frame; type: number; width: number; static getTransform(translateX: number, translateY: number, scaleX: number, scaleY: number, skewX: number, skewY: number): any; add(object: any): Phaser.BitmapData; addToWorld(x?: number, y?: number, anchorX?: number, anchorY?: number, scaleX?: number, scaleY?: number): Phaser.Image; alphaMask(source: any, mask?: any, sourceRect?: Phaser.Rectangle, maskRect?: Phaser.Rectangle): Phaser.BitmapData; blendAdd(): Phaser.BitmapData; blendColor(): Phaser.BitmapData; blendColorBurn(): Phaser.BitmapData; blendColorDodge(): Phaser.BitmapData; blendDarken(): Phaser.BitmapData; blendDestinationAtop(): Phaser.BitmapData; blendDestinationIn(): Phaser.BitmapData; blendDestinationOut(): Phaser.BitmapData; blendDestinationOver(): Phaser.BitmapData; blendDifference(): Phaser.BitmapData; blendExclusion(): Phaser.BitmapData; blendHardLight(): Phaser.BitmapData; blendHue(): Phaser.BitmapData; blendLighten(): Phaser.BitmapData; blendLuminosity(): Phaser.BitmapData; blendMultiply(): Phaser.BitmapData; blendOverlay(): Phaser.BitmapData; blendReset(): Phaser.BitmapData; blendSaturation(): Phaser.BitmapData; blendScreen(): Phaser.BitmapData; blendSoftLight(): Phaser.BitmapData; blendSourceAtop(): Phaser.BitmapData; blendSourceIn(): Phaser.BitmapData; blendSourceOut(): Phaser.BitmapData; blendSourceOver(): Phaser.BitmapData; blendXor(): Phaser.BitmapData; circle(x: number, y: number, radius: number, fillStyle?: string): Phaser.BitmapData; clear(x?: number, y?: number, width?: number, height?: number): Phaser.BitmapData; cls(): Phaser.BitmapData; copy(source?: any, x?: number, y?: number, width?: number, height?: number, tx?: number, ty?: number, newWidth?: number, newHeight?: number, rotate?: number, anchorX?: number, anchorY?: number, scaleX?: number, scaleY?: number, alpha?: number, blendMode?: string, roundPx?: boolean): Phaser.BitmapData; copyPixels(source: any, area: Phaser.Rectangle, x: number, y: number, alpha?: number): void; copyRect(source: any, area: Phaser.Rectangle, x?: number, y?: number, alpha?: number, blendMode?: string, roundPx?: boolean): Phaser.BitmapData; copyTransform(source: any, blendMode?: string, roundPx?: boolean): Phaser.BitmapData; destroy(): void; draw(source: any, x?: number, y?: number, width?: number, height?: number, blendMode?: string, roundPx?: boolean): Phaser.BitmapData; drawFull(parent: any, blendMode?: string, roundPx?: boolean): Phaser.BitmapData; drawGroup(group: Phaser.Group, blendMode?: string, roundPx?: boolean): Phaser.BitmapData; extract(destination: Phaser.BitmapData, r: number, g: number, b: number, a?: number, resize?: boolean, r2?: number, g2?: number, b2?: number): Phaser.BitmapData; fill(r: number, g: number, b: number, a?: number): Phaser.BitmapData; generateTexture(key: string): PIXI.Texture; getBounds(rect?: Phaser.Rectangle): Phaser.Rectangle; getFirstPixel(direction: number): { r: number; g: number; b: number; x: number; y: number; }; getPixel(x: number, y: number, out?: any): number; getPixelRGB(x: number, y: number, out?: any, hsl?: boolean, hsv?: boolean): any; getPixel32(x: number, y: number): number; getPixels(rect: Phaser.Rectangle): ImageData; getTransform(translateX: number, translateY: number, scaleX: number, scaleY: number, skewX: number, skewY: number): any; line(x1: number, y1: number, x2: number, y2: number, color?: string, width?: number): Phaser.BitmapData; load(source: any): Phaser.BitmapData; move(x: number, y: number, wrap?: boolean): Phaser.BitmapData; moveH(distance: number, wrap?: boolean): Phaser.BitmapData; moveV(distance: number, wrap?: boolean): Phaser.BitmapData; processPixel(callback: (color: number, x: number, y: number) => void, callbackContext: any, x?: number, y?: Number, width?: number, height?: number): Phaser.BitmapData; processPixelRGB(callback: (color: ColorComponents, x: number, y: number) => void, callbackContext: any, x?: number, y?: Number, width?: number, height?: number): Phaser.BitmapData; rect(x: number, y: number, width: number, height: number, fillStyle?: string): Phaser.BitmapData; render(): Phaser.BitmapData; replaceRGB(r1: number, g1: number, b1: number, a1: number, r2: number, g2: number, b2: number, a2: number, region?: Phaser.Rectangle): Phaser.BitmapData; resize(width: number, height: number): Phaser.BitmapData; resizeFrame(parent: any, width: number, height: number): void; setHSL(h?: number, s?: number, l?: number, region?: Phaser.Rectangle): Phaser.BitmapData; setPixel(x: number, y: number, red: number, green: number, blue: number, immediate?: boolean): Phaser.BitmapData; setPixel32(x: number, y: number, red: number, green: number, blue: number, alpha: number, immediate?: boolean): Phaser.BitmapData; shadow(color: string, blur?: number, x?: number, y?: number): Phaser.BitmapData; shiftHSL(h?: number, s?: number, l?: number, region?: Phaser.Rectangle): Phaser.BitmapData; text(text: string, x?: number, y?: number, font?: string, color?: string, shadow?: boolean): Phaser.BitmapData; textureLine(line: Phaser.Line, key: string, repeat?: string): Phaser.BitmapData; update(x?: number, y?: number, width?: number, height?: number): Phaser.BitmapData; } class BitmapText extends PIXI.DisplayObjectContainer { constructor(game: Phaser.Game, x: number, y: number, font: string, text?: string, size?: number, align?: string); align: string; alive: boolean; anchor: Phaser.Point; animations: Phaser.AnimationManager; angle: number; autoCull: boolean; body: Phaser.Physics.Arcade.Body | Phaser.Physics.P2.Body | Phaser.Physics.Ninja.Body | any; bottom: number; cameraOffset: Phaser.Point; checkWorldBounds: boolean; data: any; destroyPhase: boolean; debug: boolean; dirty: boolean; events: Phaser.Events; exists: boolean; fixedToCamera: boolean; font: string; fontSize: number; fresh: boolean; game: Phaser.Game; input: Phaser.InputHandler; inputEnabled: boolean; inCamera: boolean; inWorld: boolean; key: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture; left: number; name: string; components: any; lifespan: number; maxWidth: number; offsetX: number; offsetY: number; outOfBoundsKill: boolean; pendingDestroy: boolean; physicsType: number; previousPosition: Phaser.Point; previousRotation: number; position: Phaser.Point; renderOrderID: number; right: number; text: string; smoothed: boolean; textWidth: number; textHeight: number; tint: number; top: number; type: number; world: Phaser.Point; x: number; y: number; z: number; alignIn(container: Phaser.Rectangle | Phaser.Sprite | Phaser.Image | Phaser.Text | Phaser.BitmapText | Phaser.Button | Phaser.Graphics | Phaser.TileSprite, position?: number, offsetX?: number, offsetY?: number): any; alignTo(container: Phaser.Rectangle | Phaser.Sprite | Phaser.Image | Phaser.Text | Phaser.BitmapText | Phaser.Button | Phaser.Graphics | Phaser.TileSprite, position?: number, offsetX?: number, offsetY?: number): any; destroy(destroyChildren?: boolean): void; kill(): void; postUpdate(): void; preUpdate(): void; purgeGlyphs(): number; reset(x: number, y: number, health?: number): Phaser.BitmapText; revive(health?: number): Phaser.BitmapText; scanLine(data: any, scale: number, text: string): { width: number; text: string; end: boolean; chars: string[] }; setText(text: string): void; update(): void; updateText(): void; updateTransform(): void; } class Bullet extends Phaser.Sprite { constructor(game: Phaser.Game, x: number, y: number, key?: any, frame?: any); kill(): Phaser.Bullet; update(): void; } class Button extends Phaser.Image { constructor(game: Phaser.Game, x?: number, y?: number, key?: string, callback?: Function, callbackContext?: any, overFrame?: string | number, outFrame?: string | number, downFrame?: string | number, upFrame?: string | number); forceOut: boolean; freezeFrames: boolean; onDownSound: Phaser.Sound | Phaser.AudioSprite; onDownSoundMarker: string; onInputDown: Phaser.Signal; onInputOut: Phaser.Signal; onInputOver: Phaser.Signal; onInputUp: Phaser.Signal; onOutSound: Phaser.Sound | Phaser.AudioSprite; onOutSoundMarker: string; onOverSound: Phaser.Sound | Phaser.AudioSprite; onOverSoundMarker: string; onOverMouseOnly: boolean; onUpSound: Phaser.Sound | Phaser.AudioSprite; onUpSoundMaker: string; physicsType: number; type: number; clearFrames(): void; setDownSound(sound: Phaser.Sound | Phaser.AudioSprite, marker?: string): void; setFrames(overFrame?: string | number, outFrame?: string | number, downFrame?: string | number, upFrame?: string | number): void; onInputOverHandler(sprite: Phaser.Button, pointer: Phaser.Pointer): void; onInputOutHandler(sprite: Phaser.Button, pointer: Phaser.Pointer): void; onInputDownHandler(sprite: Phaser.Button, pointer: Phaser.Pointer): void; onInputUpHandler(sprite: Phaser.Button, pointer: Phaser.Pointer, isOver: boolean): void; removedFromWorld(): void; setOutSound(sound: Phaser.Sound | Phaser.AudioSprite, marker?: string): void; setOverSound(sound: Phaser.Sound | Phaser.AudioSprite, marker?: string): void; setSounds(overSound?: Phaser.Sound | Phaser.AudioSprite, overMarker?: string, downSound?: Phaser.Sound | Phaser.AudioSprite, downMarker?: string, outSound?: Phaser.Sound | Phaser.AudioSprite, outMarker?: string, upSound?: Phaser.Sound | Phaser.AudioSprite, upMarker?: string): void; setState(newState: number): void; setUpSound(sound: Phaser.Sound | Phaser.AudioSprite, marker?: string): void; } class PointerMode { static CURSOR: number; static CONTACT: number; } class Cache { constructor(game: Phaser.Game); static BINARY: number; static BITMAPDATA: number; static BITMAPFONT: number; static CANVAS: number; static IMAGE: number; static JSON: number; static PHYSICS: number; static RENDER_TEXTURE: number; static SHADER: number; static SOUND: number; static SPRITE_SHEET: number; static TEXT: number; static TEXTURE: number; static TEXTURE_ATLAS: number; static TILEMAP: number; static XML: number; static VIDEO: number; static DEFAULT: PIXI.Texture; static MISSING: PIXI.Texture; autoResolveURL: boolean; game: Phaser.Game; onSoundUnlock: Phaser.Signal; addBinary(key: string, binaryData: any): void; addBitmapData(key: string, bitmapData: Phaser.BitmapData, frameData?: Phaser.FrameData): Phaser.BitmapData; addBitmapFont(key: string, texture: Phaser.RetroFont): void; addBitmapFont(key: string, url: string, data: any, atlasData: any, atlasType: string, xSpacing?: number, ySpacing?: number): void; addCanvas(key: string, canvas: HTMLCanvasElement, context?: CanvasRenderingContext2D): void; addDefaultImage(): void; addImage(key: string, url: string, data: any): HTMLImageElement; addJSON(key: string, urL: string, data: any): void; addMissingImage(): void; addPhysicsData(key: string, url: string, JSONData: any, format: number): void; addRenderTexture(key: string, texture: RenderTexture): void; addShader(key: string, url: string, data: any): void; addSound(key: string, url: string, data: any, webAudio: boolean, audioTag: boolean): void; addSpriteSheet(key: string, url: string, data: any, frameWidth: number, frameHeight: number, frameMax?: number, margin?: number, spacing?: number): void; addText(key: string, url: string, data: any): void; addTextureAtlas(key: string, url: string, data: any, atlasData: any, format: number): void; addTilemap(key: string, url: string, mapData: any, format: number): void; addVideo(key: string, url: string, data: any, isBlob?: boolean): void; addXML(key: string, url: string, data: any): void; checkBinaryKey(key: string): boolean; checkBitmapDataKey(key: string): boolean; checkBitmapFontKey(key: string): boolean; checkCanvasKey(key: string): boolean; checkImageKey(key: string): boolean; checkJSONKey(key: string): boolean; checkKey(cache: number, key: string): boolean; checkPhysicsKey(key: string): boolean; checkRenderTextureKey(key: string): boolean; checkShaderKey(key: string): boolean; checkSoundKey(key: string): boolean; checkTextKey(key: string): boolean; checkTextureKey(key: string): boolean; checkTilemapKey(key: string): boolean; checkURL(url: string): any; checkUrl(url: string): any; checkXMLKey(key: string): boolean; checkVideoKey(key: string): boolean; clearGLTextures(): void; decodedSound(key: string, data: any): void; destroy(): void; getBaseTexture(key: string, cache?: number): PIXI.BaseTexture; getBinary(key: string): any; getBitmapData(key: string): Phaser.BitmapData; getBitmapFont(key: string): Phaser.BitmapFont; getCanvas(key: string): HTMLCanvasElement; getFrame(key: string, cache?: number): Phaser.Frame; getFrameByIndex(key: string, index: number, cache?: number): Phaser.Frame; getFrameByName(key: string, name: string, cache?: number): Phaser.Frame; getFrameCount(key: string, cache?: number): number; getFrameData(key: string, cache?: number): Phaser.FrameData; getImage(key: string, full?: boolean): HTMLImageElement; getItem(key: string, cache: number, method?: string, property?: string): any; getJSON(key: string, clone?: boolean): any; getKeys(cache: number): string[]; getPhysicsData(key: string, object?: string, fixtureKey?: string): any[]; getRenderTexture(key: string): Phaser.CachedRenderTexture; getShader(key: string): string; getSound(key: string): Phaser.Sound; getSoundData(key: string): any; getSpriteSheetKey(key: string): boolean; getText(key: string): string; getTextKeys(): string[]; getTexture(key: string): Phaser.RenderTexture; getTextureAtlasKey(key: string): boolean; getTextureFrame(key: string): Phaser.Frame; getTilemap(key: string): any; getTilemapData(key: string): any; getURL(url: string): any; getXML(key: string): any; getVideo(key: string): Phaser.Video; hasFrameData(key: string, cache?: number): boolean; isSoundDecoded(key: string): boolean; isSoundReady(key: string): boolean; isSpriteSheet(key: string): boolean; reloadSound(key: string): void; reloadSoundComplete(key: string): void; removeBinary(key: string): void; removeBitmapData(key: string): void; removeBitmapFont(key: string): void; removeCanvas(key: string): void; removeImage(key: string, removeFromPixi?: boolean): void; removeJSON(key: string): void; removePhysics(key: string): void; removeRenderTexture(key: string): void; removeShader(key: string): void; removeSound(key: string): void; removeSpriteSheet(key: string): void; removeText(key: string): void; removeTextureAtlas(key: string): void; removeTilemap(key: string): void; removeXML(key: string): void; removeVideo(key: string): void; updateFrameData(key: string, frameData: any, cache?: number): void; updateSound(key: string, property: string, value: Phaser.Sound): void; } interface CachedRenderTexture { frame: Phaser.Frame; texture: Phaser.RenderTexture; } class Camera { constructor(game: Phaser.Game, id: number, x: number, y: number, width: number, height: number); static FOLLOW_LOCKON: number; static FOLLOW_PLATFORMER: number; static FOLLOW_TOPDOWN: number; static FOLLOW_TOPDOWN_TIGHT: number; static SHAKE_BOTH: number; static SHAKE_HORIZONTAL: number; static SHAKE_VERTICAL: number; static ENABLE_FX: number; atLimit: { x: boolean; y: boolean; }; bounds: Phaser.Rectangle; deadzone: Phaser.Rectangle; displayObject: PIXI.DisplayObject; id: number; fx: Phaser.Graphics; game: Phaser.Game; height: number; lerp: Phaser.Point; position: Phaser.Point; roundPx: boolean; scale: Phaser.Point; shakeIntensity: number; onFadeComplete: Phaser.Signal; onFlashComplete: Phaser.Signal; onShakeComplete: Phaser.Signal; target: Phaser.Sprite; totalInView: number; view: Phaser.Rectangle; visible: boolean; width: number; world: Phaser.World; x: number; y: number; checkBounds(): void; fade(color?: number, duration?: number, force?: boolean): boolean; flash(color?: number, duration?: number, force?: boolean): boolean; focusOn(displayObject: PIXI.DisplayObject): void; focusOnXY(x: number, y: number): void; follow(target: Phaser.Sprite, style?: number, lerpX?: number, lerpY?: number): void; reset(): void; resetFX(): void; setBoundsToWorld(): void; setPosition(x: number, y: number): void; setSize(width: number, height: number): void; shake(intensity?: number, duration?: number, force?: boolean, direction?: number, shakeBounds?: boolean): boolean; unfollow(): void; update(): void; } class Canvas { static addToDOM(canvas: HTMLCanvasElement, parent: HTMLElement, overflowHidden?: boolean): HTMLCanvasElement; static create(parent: HTMLDivElement, width?: number, height?: number, id?: string, skipPool?: boolean): HTMLCanvasElement; static getSmoothingEnabled(context: CanvasRenderingContext2D): boolean; static getSmoothingPrefix(context: CanvasRenderingContext2D): string; static removeFromDOM(canvas: HTMLCanvasElement): void; static setBackgroundColor(canvas: HTMLCanvasElement, color: string): HTMLCanvasElement; static setImageRenderingBicubic(canvas: HTMLCanvasElement): HTMLCanvasElement; static setImageRenderingCrisp(canvas: HTMLCanvasElement): HTMLCanvasElement; static setSmoothingEnabled(context: CanvasRenderingContext2D, value: boolean): CanvasRenderingContext2D; static setTouchAction(canvas: HTMLCanvasElement, value: string): HTMLCanvasElement; static setTransform(context: CanvasRenderingContext2D, translateX: number, translateY: number, scaleX: number, scaleY: number, skewX: number, skewY: number): CanvasRenderingContext2D; static setUserSelect(canvas: HTMLCanvasElement, value?: string): HTMLCanvasElement; } class Circle { constructor(x?: number, y?: number, diameter?: number); area: number; bottom: number; diameter: number; empty: boolean; left: number; radius: number; right: number; top: number; x: number; y: number; static circumferencePoint(a: Phaser.Circle, angle: number, asDegrees: boolean, out?: Phaser.Point): Phaser.Point; 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 intersectsRectangle(c: Phaser.Circle, r: Phaser.Rectangle): boolean; circumference(): number; circumferencePoint(angle: number, asDegrees?: boolean, out?: Phaser.Point): Phaser.Point; clone(output: Phaser.Circle): Phaser.Circle; contains(x: number, y: number): boolean; copyFrom(source: any): Circle; copyTo(dest: any): any; distance(dest: any, round?: boolean): number; getBounds(): Phaser.Rectangle; offset(dx: number, dy: number): Phaser.Circle; offsetPoint(point: Phaser.Point): Phaser.Circle; random(out?: Phaser.Point): Phaser.Point; scale(x: number, y?: number): Phaser.Rectangle; setTo(x: number, y: number, diameter: number): Circle; toString(): string; } class Color { static componentToHex(color: number): string; static createColor(r?: number, g?: number, b?: number, a?: number, h?: number, s?: number, l?: number, v?: number): ColorComponents; static fromRGBA(rgba: number, out?: ColorComponents): ColorComponents; static getAlpha(color: number): number; static getAlphaFloat(color: number): number; static getBlue(color: number): number; static getColor(red: number, green: number, blue: number): number; static getColor32(alpha: number, red: number, green: number, blue: number): number; static getGreen(color: number): number; static getRandomColor(min?: number, max?: number, alpha?: number): number; static getRed(color: number): number; static getRGB(color: number): RGBColor; static getWebRGB(color: number | RGBColor): string; static hexToRGB(h: string): number; static hexToColor(hex: string, out?: ColorComponents): ColorComponents; static HSLtoRGB(h: number, s: number, l: number, out?: ColorComponents): ColorComponents; static HSLColorWheel(s?: number, l?: number): ColorComponents[]; static HSVtoRGB(h: number, s: number, v: number, out?: ColorComponents): ColorComponents; static HSVColorWheel(s?: number, v?: number): ColorComponents[]; static hueToColor(p: number, q: number, t: number): number; static interpolateColor(color1: number, color2: number, steps: number, currentStep: number, alpha?: number): number; static interpolateColorWithRGB(color: number, r: number, g: number, b: number, steps: number, currentStep: number): number; static interpolateRGB(r1: number, g1: number, b1: number, r2: number, g2: number, b2: number, steps: number, currentStep: number): number; static packPixel(r: number, g: number, b: number, a: number): number; static RGBtoHSL(r: number, g: number, b: number, out?: ColorComponents): ColorComponents; static RGBtoHSV(r: number, g: number, b: number, out?: ColorComponents): ColorComponents; static RGBtoString(r: number, g: number, b: number, a?: number, prefix?: string): string; static toRGBA(r: number, g: number, b: number, a: number): number; static toABGR(r: number, g: number, b: number, a: number): number; static unpackPixel(rgba: number, out?: ColorComponents, hsl?: boolean, hsv?: boolean): ColorComponents; static updateColor(out: ColorComponents): ColorComponents; static valueToColor(value: string, out?: ColorComponents): ColorComponents; static webToColor(web: string, out?: ColorComponents): ColorComponents; static blendNormal(a: number): number; static blendLighten(a: number, b: number): number; static blendDarken(a: number, b: number): number; static blendMultiply(a: number, b: number): number; static blendAverage(a: number, b: number): number; static blendAdd(a: number, b: number): number; static blendSubtract(a: number, b: number): number; static blendDifference(a: number, b: number): number; static blendNegation(a: number, b: number): number; static blendScreen(a: number, b: number): number; static blendExclusion(a: number, b: number): number; static blendOverlay(a: number, b: number): number; static blendSoftLight(a: number, b: number): number; static blendHardLight(a: number, b: number): number; static blendColorDodge(a: number, b: number): number; static blendColorBurn(a: number, b: number): number; static blendLinearDodge(a: number, b: number): number; static blendLinearBurn(a: number, b: number): number; static blendLinearLight(a: number, b: number): number; static blendVividLight(a: number, b: number): number; static blendPinLight(a: number, b: number): number; static blendHardMix(a: number, b: number): number; static blendReflect(a: number, b: number): number; static blendGlow(a: number, b: number): number; static blendPhoenix(a: number, b: number): number; } interface RGBColor { r: number; g: number; b: number; a: number; } interface ColorComponents extends RGBColor { h: number; s: number; v: number; l: number; color: number; color32: number; rgba: string; } class Create { constructor(game: Phaser.Game); static PALETTE_ARNE: number; static PALETTE_JMP: number; static PALETTE_CGA: number; static PALETTE_C64: number; static PALETTE_JAPANESE_MACHINE: number; bmd: Phaser.BitmapData; canvas: HTMLCanvasElement; ctx: CanvasRenderingContext2D; game: Phaser.Game; palettes: any; grid(key: string, width: number, height: number, cellWidth: number, cellHeight: number, color: string): PIXI.Texture; texture(key: string, data: any, pixelWidth?: number, pixelHeight?: number, palette?: number): PIXI.Texture; } interface CursorKeys { up: Phaser.Key; down: Phaser.Key; left: Phaser.Key; right: Phaser.Key; } class Device { static LITTLE_ENDIAN: boolean; static onInitialized: Phaser.Signal; static checkFullScreenSupport(): void; static canPlayAudio(type: string): boolean; static canPlayVideo(type: string): boolean; static isConsoleOpen(): boolean; static isAndroidStockBrowser(): string; static whenReady: (callback: Function, context?: any) => void; android: boolean; arora: boolean; audioData: boolean; cancelFullScreen: string; canvas: boolean; chrome: boolean; chromeOS: boolean; chromeVersion: number; cocoonJS: boolean; cocoonJSApp: boolean; cordova: boolean; crosswalk: boolean; css3D: boolean; desktop: boolean; deviceReadyAt: number; electron: boolean; ejecta: boolean; epiphany: boolean; file: boolean; fileSystem: boolean; firefox: boolean; firefoxVersion: number; fullScreen: boolean; fullScreenKeyboard: boolean; getUserMedia: boolean; game: Phaser.Game; h264Video: boolean; hlsVideo: boolean; ie: boolean; ieVersion: number; iOS: boolean; iOSVersion: number; initialized: boolean; iPad: boolean; iPhone: boolean; iPhone4: boolean; kindle: boolean; linux: boolean; littleEndian: boolean; localStorage: boolean; m4a: boolean; macOS: boolean; midori: boolean; mobileSafari: boolean; mp3: boolean; mp4Video: boolean; mspointer: boolean; node: boolean; nodeWebkit: boolean; ogg: boolean; oggVideo: number; opera: boolean; opus: boolean; pixelRatio: number; pointerLock: boolean; quirksMode: boolean; requestFullScreen: string; safari: boolean; silk: boolean; support32bit: boolean; touch: boolean; trident: boolean; tridentVersion: number; typedArray: boolean; vibration: boolean; vita: boolean; wav: boolean; webApp: boolean; webAudio: boolean; webGL: boolean; webm: boolean; webmVideo: boolean; wechatMinigame: boolean; windows: boolean; windowsPhone: boolean; wheelEvent: string; worker: boolean; wp9Video: boolean; } class DeviceButton { constructor(parent: Phaser.Pointer | Phaser.SinglePad, butonCode: number); buttonCode: number; game: Phaser.Game; isDown: boolean; isUp: boolean; onDown: Phaser.Signal; onFloat: Phaser.Signal; onUp: Phaser.Signal; pad: Phaser.Gamepad; repeats: number; timeDown: number; timeUp: number; value: number; destroy(): void; justPressed(duration?: number): boolean; justReleased(duration?: number): boolean; processButtonDown(value: number): void; processButtonFloat(value: number): void; processButtonUp(value: number): void; reset(): void; } module Easing { var Default: Function; var Power0: Function; var Power1: Function; var power2: Function; var power3: Function; var power4: Function; 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 Circular { 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 Elastic { 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 Linear { static None(k: number): number; } class Quadratic { 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 Ellipse { constructor(x?: number, y?: number, width?: number, height?: number); bottom: number; empty: boolean; height: number; left: number; right: number; top: number; type: number; width: number; x: number; y: number; static constains(a: Phaser.Ellipse, x: number, y: number): boolean; clone(output: Phaser.Ellipse): Phaser.Ellipse; contains(x: number, y: number): boolean; copyFrom(source: any): Phaser.Ellipse; copyTo(dest: any): any; getBounds(): Phaser.Rectangle; random(out?: Phaser.Point): Phaser.Point; setTo(x: number, y: number, width: number, height: number): Phaser.Ellipse; toString(): string; } class Events { constructor(sprite: Phaser.Sprite); parent: Phaser.Sprite; onAddedToGroup: Phaser.Signal; onRemovedFromGroup: Phaser.Signal; onRemovedFromWorld: Phaser.Signal; onKilled: Phaser.Signal; onRevived: Phaser.Signal; onOutOfBounds: Phaser.Signal; onEnterBounds: Phaser.Signal; onInputOver: Phaser.Signal; onInputOut: Phaser.Signal; onInputDown: Phaser.Signal; onInputUp: Phaser.Signal; onDestroy: Phaser.Signal; onDragStart: Phaser.Signal; onDragStop: Phaser.Signal; onDragUpdate: Phaser.Signal; onAnimationStart: Phaser.Signal; onAnimationComplete: Phaser.Signal; onAnimationLoop: Phaser.Signal; destroy(): void; } class Filter extends PIXI.AbstractFilter { constructor(game: Phaser.Game, uniforms: any, fragmentSrc: string | string[]); dirty: boolean; game: Phaser.Game; height: number; fragmentSrc: string | string[]; padding: number; prevPoint: Phaser.Point; type: number; uniforms: any; width: number; addToWorld(x?: number, y?: number, width?: number, height?: number, anchorX?: number, anchorY?: number): Phaser.Image; apply(frameBuffer: WebGLFramebuffer): void; destroy(): void; init(...args: any[]): void; setResolution(width: number, height: number): void; syncUniforms(): void; update(pointer?: Phaser.Pointer): void; } module Filter { class BinarySerpents extends Phaser.Filter { constructor(game: Phaser.Game, width: number, height: number, march?: number, maxDistance?: number); fog: number; } class BlurX extends Phaser.Filter { blur: number; } class BlurY extends Phaser.Filter { blur: number; } class CausticLight extends Phaser.Filter { constructor(game: Phaser.Game, width: number, height: number, divisor?: number); init(width: number, height: number, divisor?: number): void; } class CheckerWave extends Phaser.Filter { constructor(game: Phaser.Game, width: number, height: number); alpha: number; cameraX: number; cameraY: number; cameraZ: number; init(width: number, height: number): void; setColor1(red: number, green: number, blue: number): void; setColor2(red: number, green: number, blue: number): void; } class ColorBars extends Phaser.Filter { constructor(game: Phaser.Game, width: number, height: number); alpha: number; init(width: number, height: number): void; } class Fire extends Phaser.Filter { constructor(width: number, height: number, alpha?: number, shift?: number); alpha: number; shift: number; speed: number; init(width: number, height: number, alpha?: number, shift?: number): void; } class Gray extends Phaser.Filter { gray: number; } class HueRotate extends Phaser.Filter { constructor(game: Phaser.Game, width: number, height: number, texture: any); alpha: number; init(width: number, height: number, texture: any): void; } class LazerBeam extends Phaser.Filter { init(width: number, height: number, divisor?: number): void; } class LightBeam extends Phaser.Filter { constructor(game: Phaser.Game, width: number, height: number); alpha: number; blue: number; green: number; red: number; thickness: number; speed: number; init(width: number, height: number): void; } class Marble extends Phaser.Filter { constructor(game: Phaser.Game, width: number, height: number, speed?: number, intensity?: number); alpha: number; intensity: number; speed: number; init(width: number, height: number, speed?: number, intensity?: number): void; } class Pixelate extends Phaser.Filter { size: number; sizeX: number; sizeY: number; } class Plasma extends Phaser.Filter { constructor(game: Phaser.Game, width: number, height: number, alpha?: number, size?: number); alpha: number; blueShift: number; greenShift: number; redShift: number; size: number; init(width: number, height: number, alpha?: number, size?: number): void; } class SampleFilter extends Phaser.Filter { constructor(game: Phaser.Game, width: number, height: number, divisor?: number); init(width: number, height: number, divisor?: number): void; } class Tunnel extends Phaser.Filter { constructor(game: Phaser.Game, width: number, height: number, texture: any); alpha: number; origin: number; init(width: number, height: number, texture: any): void; } } class FlexGrid { constructor(manager: Phaser.ScaleManager, width: number, height: number); game: Phaser.Game; manager: Phaser.ScaleManager; width: number; height: number; boundsCustom: Phaser.Rectangle; boundsFluid: Phaser.Rectangle; boundsFull: Phaser.Rectangle; boundsNone: Phaser.Rectangle; customWidth: number; customHeight: number; customOffsetX: number; customOffsetY: number; positionCustom: Phaser.Point; positionFluid: Phaser.Point; positionFull: Phaser.Point; positionNone: Phaser.Point; scaleCustom: Phaser.Point; scaleFluid: Phaser.Point; scaleFluidInversed: Phaser.Point; scaleFull: Phaser.Point; scaleNone: Phaser.Point; ratioH: number; ratioV: number; multiplier: number; createCustomLayer(width: number, height: number, children?: PIXI.DisplayObject[], addToWorld?: boolean): Phaser.FlexLayer; createFluidLayer(children: PIXI.DisplayObject[]): Phaser.FlexLayer; createFullLayer(children: PIXI.DisplayObject[]): Phaser.FlexLayer; createFixedLayer(children: PIXI.DisplayObject[]): Phaser.FlexLayer; debug(): void; fitSprite(sprite: Phaser.Sprite): void; onResize(width: number, height: number): void; refresh(): void; reset(): void; setSize(width: number, height: number): void; } class FlexLayer extends Phaser.Group { constructor(manager: Phaser.ScaleManager, position: Phaser.Point, bounds: Phaser.Rectangle, scale: Phaser.Point); grid: Phaser.FlexGrid; manager: Phaser.ScaleManager; bottomLeft: Phaser.Point; bottomMiddle: Phaser.Point; bottomRight: Phaser.Point; bounds: Phaser.Rectangle; persist: boolean; position: Phaser.Point; scale: Phaser.Point; topLeft: Phaser.Point; topMiddle: Phaser.Point; topRight: Phaser.Point; debug(): void; resize(): void; } class Frame { constructor(index: number, x: number, y: number, width: number, height: number, name: string); bottom: number; centerX: number; centerY: number; distance: number; height: number; index: number; name: string; right: number; rotated: boolean; rotationDirection: string; sourceSizeH: number; sourceSizeW: number; spriteSourceSizeH: number; spriteSourceSizeW: number; spriteSourceSizeX: number; spriteSourceSizeY: number; trimmed: boolean; uuid: string; width: number; x: number; y: number; clone(): Phaser.Frame; getRect(out?: Phaser.Rectangle): Phaser.Rectangle; setTrim(trimmed: boolean, actualWidth: number, actualHeight: number, destX: number, destY: number, destWidth: number, destHeight: number): void; resize(width: number, height: number): void; } class FrameData { total: number; addFrame(frame: Frame): Phaser.Frame; checkFrameName(name: string): boolean; clone(): Phaser.FrameData; getFrame(index: number): Phaser.Frame; getFrameByName(name: string): Phaser.Frame; getFrameIndexes(frames?: number[], useNumericIndex?: boolean, output?: number[]): number[]; getFrameRange(start: number, end: number, output: Phaser.Frame[]): Phaser.Frame[]; getFrames(frames?: number[], useNumericIndex?: boolean, output?: Phaser.Frame[]): Phaser.Frame[]; } interface IGameConfig { enableDebug?: boolean; width?: number; height?: number; renderer?: number; parent?: any; transparent?: boolean; antialias?: boolean; resolution?: number; preserveDrawingBuffer?: boolean; physicsConfig?: any; seed?: string; state?: Phaser.State; forceSetTimeOut: boolean; } class Game { constructor(width?: number | string, height?: number | string, renderer?: number, parent?: any, state?: any, transparent?: boolean, antialias?: boolean, physicsConfig?: any); constructor(config: IGameConfig); add: Phaser.GameObjectFactory; antialias: boolean; cache: Phaser.Cache; camera: Phaser.Camera; canvas: HTMLCanvasElement; clearBeforeRender: boolean; config: IGameConfig; context: CanvasRenderingContext2D; count: number; create: Phaser.Create; debug: Phaser.Utils.Debug; device: Phaser.Device; forceSingleUpdate: boolean; fpsProblemNotifier: Phaser.Signal; height: number; id: number; input: Phaser.Input; isBooted: boolean; isRunning: boolean; load: Phaser.Loader; lockRender: boolean; make: Phaser.GameObjectCreator; math: Phaser.Math; net: Phaser.Net; onBlur: Phaser.Signal; onFocus: Phaser.Signal; onPause: Phaser.Signal; onResume: Phaser.Signal; parent: HTMLElement; particles: Phaser.Particles; paused: boolean; pendingStep: boolean; physics: Phaser.Physics; physicsConfig: any; plugins: PluginManager; preserveDrawingBuffer: Boolean; raf: Phaser.RequestAnimationFrame; renderer: PIXI.CanvasRenderer | PIXI.WebGLRenderer; renderType: number; resolution: number; rnd: Phaser.RandomDataGenerator; scale: Phaser.ScaleManager; scratch: Phaser.BitmapData; sound: Phaser.SoundManager; stage: Phaser.Stage; state: Phaser.StateManager; stepCount: number; stepping: boolean; time: Phaser.Time; transparent: boolean; tweens: Phaser.TweenManager; currentUpdateID: number; updatesThisFrame: number; width: number; world: Phaser.World; boot(): void; destroy(): void; disableStep(): void; enableStep(): void; focusGain(event: any): void; focusLoss(event: any): void; gamePaused(event: any): void; gameResumed(event: any): void; parseConfig(config: any): void; removeFromDOM(canvas: HTMLCanvasElement): void; setUpRenderer(): void; showDebugHeader(): void; step(): void; update(time: number): void; updateLogic(timeStep: number): void; updateRender(timeStep: number): void; } class GameObjectCreator { constructor(game: Phaser.Game); game: Phaser.Game; world: Phaser.World; audio(key: string, volume?: number, loop?: boolean, connect?: boolean): Phaser.Sound; audioSprite(key: string): Phaser.AudioSprite; bitmapData(width?: number, height?: number, key?: string, addToCache?: boolean): Phaser.BitmapData; bitmapText(x: number, y: number, font: string, text?: string, size?: number, align?: string): Phaser.BitmapText; button(x?: number, y?: number, key?: string, callback?: Function, callbackContext?: any, overFrame?: any, outFrame?: any, downFrame?: any, upFrame?: any): Phaser.Button; emitter(x?: number, y?: number, maxParticles?: number): Phaser.Particles.Arcade.Emitter; filter(filter: any, ...args: any[]): Phaser.Filter; graphics(x?: number, y?: number): Phaser.Graphics; group(parent?: any, name?: string, addToStage?: boolean, enableBody?: boolean, physicsBodyType?: number): Phaser.Group; image(x: number, y: number, key?: any, frame?: any): Phaser.Image; renderTexture(width?: number, height?: number, key?: any, addToCache?: boolean): Phaser.RenderTexture; retroFont(font: string, characterWidth: number, characterHeight: number, chars: string, charsPerRow: number, xSpacing?: number, ySpacing?: number, xOffset?: number, yOffset?: number): Phaser.RetroFont; rope(x: number, y: number, key: any, frame?: any, points?: Phaser.Point[]): Phaser.Rope; sound(key: string, volume?: number, loop?: boolean, connect?: boolean): Phaser.Sound; sprite(x: number, y: number, key?: any, frame?: any): Phaser.Sprite; spriteBatch(parent: any, name?: String, addToStage?: boolean): Phaser.SpriteBatch; text(x: number, y: number, text?: string, style?: any): Phaser.Text; tilemap(key: string, tileWidth?: number, tileHeight?: number, width?: number, height?: number): Phaser.Tilemap; tileSprite(x: number, y: number, width: number, height: number, key: any, frame: any): Phaser.TileSprite; tween(obj: any): Phaser.Tween; } class GameObjectFactory { constructor(game: Phaser.Game); game: Phaser.Game; world: Phaser.World; audio(key: string, volume?: number, loop?: boolean, connect?: boolean): Phaser.Sound; audioSprite(key: string): Phaser.AudioSprite; bitmapData(width?: number, height?: number, key?: string, addToCache?: boolean): Phaser.BitmapData; bitmapText(x: number, y: number, font: string, text?: string, size?: number, group?: Phaser.Group): Phaser.BitmapText; button(x?: number, y?: number, key?: string, callback?: Function, callbackContext?: any, overFrame?: any, outFrame?: any, downFrame?: any, upFrame?: any, group?: Phaser.Group): Phaser.Button; emitter(x?: number, y?: number, maxParticles?: number): Phaser.Particles.Arcade.Emitter; existing(object: any): any; filter(filter: string, ...args: any[]): Phaser.Filter; graphics(x: number, y: number, group?: Phaser.Group): Phaser.Graphics; group(parent?: any, name?: string, addToStage?: boolean, enableBody?: boolean, physicsBodyType?: number): Phaser.Group; image(x: number, y: number, key?: any, frame?: any, group?: Phaser.Group): Phaser.Image; physicsGroup(physicsBodyType?: number, parent?: any, name?: string, addToStage?: boolean): Phaser.Group; plugin(plugin: Phaser.Plugin, ...parameter: any[]): Phaser.Plugin; renderTexture(width?: number, height?: number, key?: string, addToCache?: boolean): Phaser.RenderTexture; retroFont(font: string, characterWidth: number, characterHeight: number, chars: string, charsPerRow: number, xSpacing?: number, ySpacing?: number, xOffset?: number, yOffset?: number): Phaser.RetroFont; rope(x: number, y: number, key: any, frame?: any, points?: Phaser.Point[]): Phaser.Rope; sound(key: string, volume?: number, loop?: boolean, connect?: boolean): Phaser.Sound; sprite(x: number, y: number, key?: any, frame?: any, group?: Phaser.Group): Phaser.Sprite; spriteBatch(parent: any, name?: string, addToStage?: boolean): Phaser.Group; text(x: number, y: number, text: string, style: any, group?: Phaser.Group): Phaser.Text; tilemap(key?: string, tileWidth?: number, tileHeight?: number, width?: number, height?: number): Phaser.Tilemap; tileSprite(x: number, y: number, width: number, height: number, key?: any, frame?: any, group?: Phaser.Group): Phaser.TileSprite; tween(obj: any): Phaser.Tween; weapon(quantity?: number, key?: any, frame?: any, group?: Phaser.Group): Phaser.Weapon; video(key?: string, url?: string): Phaser.Video; } class Gamepad { constructor(game: Phaser.Game); static BUTTON_0: number; static BUTTON_1: number; static BUTTON_2: number; static BUTTON_3: number; static BUTTON_4: number; static BUTTON_5: number; static BUTTON_6: number; static BUTTON_7: number; static BUTTON_8: number; static BUTTON_9: number; static BUTTON_10: number; static BUTTON_11: number; static BUTTON_12: number; static BUTTON_13: number; static BUTTON_14: number; static BUTTON_15: number; static AXIS_0: number; static AXIS_1: number; static AXIS_2: number; static AXIS_3: number; static AXIS_4: number; static AXIS_5: number; static AXIS_6: number; static AXIS_7: number; static AXIS_8: number; static AXIS_9: number; static XBOX360_A: number; static XBOX360_B: number; static XBOX360_X: number; static XBOX360_Y: number; static XBOX360_LEFT_BUMPER: number; static XBOX360_RIGHT_BUMPER: number; static XBOX360_LEFT_TRIGGER: number; static XBOX360_RIGHT_TRIGGER: number; static XBOX360_BACK: number; static XBOX360_START: number; static XBOX360_STICK_LEFT_BUTTON: number; static XBOX360_STICK_RIGHT_BUTTON: number; static XBOX360_DPAD_LEFT: number; static XBOX360_DPAD_RIGHT: number; static XBOX360_DPAD_UP: number; static XBOX360_DPAD_DOWN: number; static XBOX360_STICK_LEFT_X: number; static XBOX360_STICK_LEFT_Y: number; static XBOX360_STICK_RIGHT_X: number; static XBOX360_STICK_RIGHT_Y: number; static PS3XC_X: number; static PS3XC_CIRCLE: number; static PS3XC_SQUARE: number; static PS3XC_TRIANGLE: number; static PS3XC_L1: number; static PS3XC_R1: number; static PS3XC_L2: number; static PS3XC_R2: number; static PS3XC_SELECT: number; static PS3XC_START: number; static PS3XC_STICK_LEFT_BUTTON: number; static PS3XC_STICK_RIGHT_BUTTON: number; static PS3XC_DPAD_UP: number; static PS3XC_DPAD_DOWN: number; static PS3XC_DPAD_LEFT: number; static PS3XC_DPAD_RIGHT: number; static PS3XC_STICK_LEFT_X: number; static PS3XC_STICK_LEFT_Y: number; static PS3XC_STICK_RIGHT_X: number; static PS3XC_STICK_RIGHT_Y: number; active: boolean; callbackContext: any; enabled: boolean; game: Phaser.Game; onAxisCallBack: Function; onConnectCallback: Function; onDisconnectCallback: Function; onDownCallback: Function; onFloatCallback: Function; onUpCallback: Function; pad1: Phaser.SinglePad; pad2: Phaser.SinglePad; pad3: Phaser.SinglePad; pad4: Phaser.SinglePad; padsConnected: number; supported: boolean; addCallbacks(context: any, callbacks: any): void; isDown(buttonCode: number): boolean; justPressed(buttonCode: number, duration?: number): boolean; justReleased(buttonCode: number, duration?: number): boolean; reset(): void; setDeadZones(value: any): void; start(): void; stop(): void; update(): void; } class Graphics extends PIXI.Graphics { constructor(game: Phaser.Game, x?: number, y?: number); angle: number; alive: boolean; animations: Phaser.AnimationManager; autoCull: boolean; body: Phaser.Physics.Arcade.Body | Phaser.Physics.P2.Body | Phaser.Physics.Ninja.Body | any; bottom: number; cameraOffset: Phaser.Point; checkWorldBounds: boolean; components: any; data: any; debug: boolean; destroyPhase: boolean; exists: boolean; events: Phaser.Events; fixedToCamera: boolean; key: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture; fresh: boolean; game: Phaser.Game; height: number; input: Phaser.InputHandler; inputEnabled: boolean; inCamera: boolean; inWorld: boolean; left: number; name: string; lifespan: number; offsetX: number; offsetY: number; outOfBoundsKill: boolean; pendingDestroy: boolean; physicsType: number; position: Phaser.Point; previousPosition: Phaser.Point; previousRotation: number; renderOrderID: number; right: number; top: number; type: number; world: Phaser.Point; width: number; z: number; alignIn(container: Phaser.Rectangle | Phaser.Sprite | Phaser.Image | Phaser.Text | Phaser.BitmapText | Phaser.Button | Phaser.Graphics | Phaser.TileSprite, position?: number, offsetX?: number, offsetY?: number): any; alignTo(container: Phaser.Rectangle | Phaser.Sprite | Phaser.Image | Phaser.Text | Phaser.BitmapText | Phaser.Button | Phaser.Graphics | Phaser.TileSprite, position?: number, offsetX?: number, offsetY?: number): any; destroy(destroyChildren?: boolean): void; drawTriangle(points: Phaser.Point[], cull?: boolean): void; drawTriangles(vertices: Phaser.Point[] | number[], indices?: number[], cull?: boolean): void; kill(): Phaser.Graphics; postUpdate(): void; preUpdate(): void; reset(x: number, y: number, health?: number): Phaser.Graphics; revive(health?: number): Phaser.Graphics; update(): void; } class Group extends PIXI.DisplayObjectContainer { constructor(game: Phaser.Game, parent?: PIXI.DisplayObjectContainer, name?: string, addToStage?: boolean, enableBody?: boolean, physicsBodyType?: number); static RETURN_CHILD: number; static RETURN_NONE: number; static RETURN_TOTAL: number; static RETURN_ALL: number; static SORT_ASCENDING: number; static SORT_DESCENDING: number; alpha: number; angle: number; alive: boolean; bottom: number; cameraOffset: Phaser.Point; centerX: number; centerY: number; classType: any; cursor: any; cursorIndex: number; enableBody: boolean; enableBodyDebug: boolean; exists: boolean; fixedToCamera: boolean; game: Phaser.Game; hash: PIXI.DisplayObject[]; ignoreDestroy: boolean; inputEnableChildren: boolean; left: number; length: number; name: string; onChildInputDown: Phaser.Signal; onChildInputUp: Phaser.Signal; onChildInputOver: Phaser.Signal; onChildInputOut: Phaser.Signal; onDestroy: Phaser.Signal; pendingDestroy: boolean; physicsBodyType: number; physicsType: number; physicsSortDirection: number; position: Phaser.Point; right: number; rotation: number; scale: Phaser.Point; top: number; total: number; type: number; visible: boolean; z: number; add(child: any, silent?: boolean, index?: number): any; addAll(property: string, amount: number, checkAlive: boolean, checkVisible: boolean): void; addAt(child: any, index: number, silent?: boolean): any; addMultiple(children: any[], silent?: boolean): any[]; addToHash(child: PIXI.DisplayObject): boolean; align(width: number, height: number, cellWidth: number, cellHeight: number, position?: number, offset?: number): boolean; alignIn(container: Phaser.Rectangle | Phaser.Sprite | Phaser.Image | Phaser.Text | Phaser.BitmapText | Phaser.Button | Phaser.Graphics | Phaser.TileSprite, position?: number, offsetX?: number, offsetY?: number): Phaser.Group; alignTo(container: Phaser.Rectangle | Phaser.Sprite | Phaser.Image | Phaser.Text | Phaser.BitmapText | Phaser.Button | Phaser.Graphics | Phaser.TileSprite, position?: number, offsetX?: number, offsetY?: number): Phaser.Group; bringToTop(child: any): any; callAll(method: string, context: any, ...parameters: any[]): void; callAllExists(callback: string, existsValue: boolean, ...parameters: any[]): void; callbackFromArray(child: any, callback: Function, length: number): void; checkAll(key: string[], value: any, checkAlive?: boolean, checkVisible?: boolean, force?: boolean): boolean; checkProperty(child: any, key: string[], value: any, force?: boolean): boolean; countDead(): number; countLiving(): number; create(x: number, y: number, key?: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture, frame?: string | number, exists?: boolean, index?: number): any; createMultiple(quantity: number, key: string | string[], frame?: any | any[], exists?: boolean): any[]; customSort(sortHandler: Function, context?: any): void; destroy(destroyChildren?: boolean, soft?: boolean): void; divideAll(property: string, amount: number, checkAlive?: boolean, checkVisible?: boolean): void; forEach(callback: Function, callbackContext: any, checkExists?: boolean, ...args: any[]): void; forEachAlive(callback: Function, callbackContext: any, ...args: any[]): void; forEachDead(callback: Function, callbackContext: any, ...args: any[]): void; forEachExists(callback: Function, callbackContext: any): void; filter(predicate: Function, checkExists?: boolean): ArraySet; getAt(index: number): PIXI.DisplayObject | number; getBottom(): any; getByName(name: string): any; getClosestTo(object: any, callback?: Function, callbackContext?: any): any; getFirstAlive(createIfNull?: boolean, x?: number, y?: number, key?: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture, frame?: string | number): any; getFirstDead(createIfNull?: boolean, x?: number, y?: number, key?: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture, frame?: string | number): any; getFirstExists(exists: boolean, createIfNull?: boolean, x?: number, y?: number, key?: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture, frame?: string | number): any; getFurthestFrom(object: any, callback?: Function, callbackContext?: any): any; getIndex(child: any): number; getRandom(startIndex?: number, length?: number): any; getTop(): any; hasProperty(child: any, key: string[]): boolean; iterate(key: string, value: any, returnType: number, callback?: Function, callbackContext?: any, ...args: any[]): any; moveAll(group: Phaser.Group, silent?: boolean): Phaser.Group; moveDown(child: any): any; moveUp(child: any): any; multiplyAll(property: string, amount: number, checkAlive: boolean, checkVisible: boolean): void; next(): void; postUpdate(): void; preUpdate(): void; previous(): void; remove(child: any, destroy?: boolean, silent?: boolean): boolean; removeAll(destroy?: boolean, silent?: boolean, destroyTexture?: boolean): void; removeBetween(startIndex: number, endIndex?: number, destroy?: boolean, silent?: boolean): void; removeFromHash(child: PIXI.DisplayObject): boolean; replace(oldChild: any, newChild: any): any; resetChild(child: any, x?: number, y?: number, key?: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture, frame?: string | number): any; resetCursor(index?: number): any; reverse(): void; sendToBack(child: any): any; set(child: any, key: string[], value: any, operation?: number, force?: boolean): boolean; setAll(key: string, value: any, checkAlive?: boolean, checkVisible?: boolean, operation?: number, force?: boolean): void; setAllChildren(key: string, value: any, checkAlive?: boolean, checkVisible?: boolean, operation?: number, force?: boolean): void; setProperty(child: any, key: string[], value: any, operation?: number, force?: boolean): boolean; sort(key?: string, order?: number): void; subAll(property: string, amount: number, checkAlive: boolean, checkVisible: boolean): void; swap(child1: any, child2: any): boolean; update(): void; updateZ(): void; xy(index: number, x: number, y: number): void; } class Image extends PIXI.Sprite { constructor(game: Phaser.Game, x: number, y: number, key: string | Phaser.RenderTexture | Phaser.BitmapData | PIXI.Texture, frame?: string | number); alive: boolean; angle: number; anchor: Phaser.Point; animations: Phaser.AnimationManager; autoCull: boolean; bottom: number; cameraOffset: Phaser.Point; centerX: number; centerY: number; components: any; cropRect: Phaser.Rectangle; customRender: boolean; data: any; debug: boolean; deltaX: number; deltaY: number; deltaZ: number; destroyPhase: boolean; events: Phaser.Events; exists: boolean; fixedToCamera: boolean; frame: string | number; frameName: string; fresh: boolean; game: Phaser.Game; inCamera: boolean; input: Phaser.InputHandler; inputEnabled: boolean; inWorld: boolean; key: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture; lifespan: number; left: number; name: string; offsetX: number; offsetY: number; pendingDestroy: boolean; position: Phaser.Point; previousPosition: Phaser.Point; previousRotation: number; renderOrderID: number; right: number; scale: Phaser.Point; smoothed: boolean; top: number; type: number; world: Phaser.Point; z: number; alignIn(container: Phaser.Rectangle | Phaser.Sprite | Phaser.Image | Phaser.Text | Phaser.BitmapText | Phaser.Button | Phaser.Graphics | Phaser.TileSprite, position?: number, offsetX?: number, offsetY?: number): any; alignTo(container: Phaser.Rectangle | Phaser.Sprite | Phaser.Image | Phaser.Text | Phaser.BitmapText | Phaser.Button | Phaser.Graphics | Phaser.TileSprite, position?: number, offsetX?: number, offsetY?: number): any; bringToTop(): Phaser.Image; crop(rect: Phaser.Rectangle, copy?: boolean): void; destroy(destroyChildren?: boolean): void; kill(): Phaser.Image; loadTexture(key: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture, frame?: string | number, stopAnimation?: boolean): void; resizeFrame(parent: any, width: number, height: number): void; moveDown(): Phaser.Image; moveUp(): Phaser.Image; overlap(displayObject: Phaser.Sprite | Phaser.Image | Phaser.TileSprite | Phaser.Button | PIXI.DisplayObject): boolean; play(name: string, frameRate?: number, loop?: boolean, killOnComplete?: boolean): Phaser.Animation; postUpdate(): void; preUpdate(): void; reset(x: number, y: number, health?: number): Phaser.Image; resetFrame(): void; revive(health?: number): Phaser.Image; sendToBack(): Phaser.Image; setFrame(frame: Phaser.Frame): void; update(): void; updateCrop(): void; } class ImageCollection { constructor(name: string, firstgid: number, width?: number, height?: number, margin?: number, spacing?: number, properties?: any); name: string; firstgid: number; imageWidth: number; imageHeight: number; imageMargin: number; imageSpacing: number; properties: any; images: any[]; total: number; addImage(gid: number, image: string): void; containsImageIndex(imageIndex: number): boolean; } class Input { constructor(game: Phaser.Game); static MAX_POINTERS: number; static MOUSE_OVERRIDES_TOUCH: number; static MOUSE_TOUCH_COMBINE: number; static TOUCH_OVERRIDES_MOUSE: number; activePointer: Phaser.Pointer; circle: Phaser.Circle; enabled: boolean; doubleTapRate: number; game: Phaser.Game; gamepad: Phaser.Gamepad; hitCanvas: HTMLCanvasElement; hitContext: CanvasRenderingContext2D; holdRate: number; interactiveItems: Phaser.ArraySet; justPressedRate: number; justReleasedRate: number; keyboard: Phaser.Keyboard; maxPointers: number; minPriorityID: number; mouse: Phaser.Mouse; mousePointer: Phaser.Pointer; moveCallbacks: (pointer: Phaser.Pointer, x: number, y: number) => void[]; mspointer: Phaser.MSPointer; multiInputOverride: number; onDown: Phaser.Signal; onHold: Phaser.Signal; onTap: Phaser.Signal; onUp: Phaser.Signal; 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; pollLocked: boolean; pollRate: number; position: Phaser.Point; pointer: Phaser.Pointer[]; recordLimit: number; recordPointerHistory: boolean; recordRate: number; resetLocked: boolean; scale: Phaser.Point; speed: Phaser.Point; tapRate: number; totalActivePointers: number; totalInactivePointers: number; touch: Phaser.Touch; worldX: number; worldY: number; x: number; y: number; addPointer(): Phaser.Pointer; addMoveCallback(callback: Function, context: any): number; boot(): void; countActivePointers(limit?: number): number; deleteMoveCallback(callback: Function, context?: any): void; destroy(): void; getLocalPosition(displayObject: any, pointer: Phaser.Pointer): Phaser.Point; getPointer(isActive?: boolean): Phaser.Pointer; getPointerFromId(pointerID: number): Phaser.Pointer; getPointerFromIdentifier(identifier: number): Phaser.Pointer; hitTest(displayObject: PIXI.DisplayObject, pointer: Phaser.Pointer, localPoint: Phaser.Point): void; reset(hard?: boolean): void; resetSpeed(x: number, y: number): void; setInteractiveCandidateHandler(callback: Function, context?: any): void; startPointer(event: any): Phaser.Pointer; stopPointer(event: any): Phaser.Pointer; update(): void; updatePointer(event: any): Phaser.Pointer; } class InputHandler { constructor(sprite: Phaser.Sprite); allowHorizontalDrag: boolean; allowVerticalDrag: boolean; boundsRect: Phaser.Rectangle; boundsSprite: Phaser.Sprite; bringToTop: boolean; downPoint: Phaser.Point; dragDistanceThreshold: number; dragOffset: Phaser.Point; dragFromCenter: boolean; draggable: boolean; dragStartPoint: Phaser.Point; dragStopBlocksInputUp: boolean; dragTimeThreshold: number; enabled: boolean; game: Phaser.Game; globalToLocalX(x: number): number; globalToLocalY(y: number): number; isDragged: boolean; pixelPerfectAlpha: number; pixelPerfectClick: boolean; pixelPerfectOver: boolean; priorityID: number; scaleLayer: boolean; snapOffset: Phaser.Point; snapOffsetX: number; snapOffsetY: number; snapOnDrag: boolean; snapOnRelease: boolean; snapPoint: Phaser.Point; snapX: number; snapY: number; sprite: Phaser.Sprite; useHandCursor: boolean; checkBoundsRect(): void; checkBoundsSprite(): void; checkPixel(x: number, y: number, pointer?: Phaser.Pointer): boolean; checkPointerDown(pointer: Phaser.Pointer, fastTest?: boolean): boolean; checkPointerOver(pointer: Phaser.Pointer, fastTest?: boolean): boolean; destroy(): void; disableDrag(): void; disableSnap(): void; downDuration(pointerId?: number): number; enableDrag(lockCenter?: boolean, bringToTop?: boolean, pixelPerfect?: boolean, alphaThreshold?: number, boundsRect?: Phaser.Rectangle, boundsSprite?: Phaser.Sprite): void; enableSnap(snapX: number, snapY: number, onDrag?: boolean, onRelease?: boolean, snapOffsetX?: number, snapOffsetY?: number): void; isPixelPerfect(): boolean; justOut(pointerId?: number, delay?: number): boolean; justOver(pointerId?: number, delay?: number): boolean; justPressed(pointerId?: number, delay?: number): boolean; justReleased(pointerId?: number, delay?: number): boolean; overDuration(pointerId?: number): number; pointerDown(pointerId?: number): boolean; pointerDragged(pointerId?: number): boolean; pointerOut(pointerId?: number): boolean; pointerOver(pointerId?: number): boolean; pointerTimeDown(pointerId?: number): number; pointerTimeOut(pointerId?: number): number; pointerTimeOver(pointerId?: number): number; pointerTimeUp(pointerId?: number): number; pointerUp(pointerId?: number): boolean; pointerX(pointerId?: number): number; pointerY(pointerId?: number): number; reset(): void; setDragLock(allowHorizontal?: boolean, allowVertical?: boolean): void; start(priority: number, useHandCursor: boolean): Phaser.Sprite; startDrag(pointer: Phaser.Pointer): void; stop(): void; stopDrag(pointer: Phaser.Pointer): void; update(pointer: Phaser.Pointer): void; updateDrag(pointer: Phaser.Pointer): boolean; validForInput(highestID: number, highestRenderID: number, includePixelPerfect?: boolean): boolean; } class Key { constructor(game: Phaser.Game, keycode: number); altKey: boolean; ctrlKey: boolean; duration: number; enabled: boolean; event: any; game: Phaser.Game; isDown: boolean; isUp: boolean; _justDown: boolean; justDown: boolean; _justUp: boolean; justUp: boolean; keyCode: number; onDown: Phaser.Signal; onHoldCallback: Function; onHoldContext: any; onUp: Phaser.Signal; repeats: number; shiftKey: boolean; timeDown: number; timeUp: number; downDuration(duration?: number): boolean; processKeyDown(event: KeyboardEvent): void; processKeyUp(event: KeyboardEvent): void; reset(hard?: boolean): void; update(): void; upDuration(duration?: number): boolean; } class Keyboard { constructor(game: Phaser.Game); 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 COMMA: number; static UNDERSCORE: number; static PERIOD: 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; static PLUS: number; static MINUS: number; callbackContext: any; enabled: boolean; event: any; game: Phaser.Game; lastChar: string; lastKey: Phaser.Key; onDownCallback: Function; onPressCallback: Function; onUpCallback: Function; pressEvent: any; addCallbacks(context: any, onDown?: Function, onUp?: Function, onPress?: Function): void; addKey(keycode: number): Phaser.Key; addKeys(keys: any): any; addKeyCapture(keycode: any): void; createCursorKeys(): Phaser.CursorKeys; clearCaptures(): void; destroy(): void; downDuration(keycode: number, duration?: number): boolean; isDown(keycode: number): boolean; processKeyDown(event: KeyboardEvent): void; processKeyPress(event: KeyboardEvent): void; processKeyUp(event: KeyboardEvent): void; removeKey(keycode: number): void; removeKeyCapture(keycode: number): void; reset(hard?: boolean): void; start(): void; stop(): void; update(): void; upDuration(keycode: number, duration?: number): boolean; } class KeyCode { 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 COMMA: number; static UNDERSCORE: number; static PERIOD: 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; static PLUS: number; static MINUS: number; } class Line { constructor(x1?: number, y1?: number, x2?: number, y2?: number); angle: number; end: Phaser.Point; height: number; left: number; length: number; normalAngle: number; normalX: number; normalY: number; perpSlope: number; right: number; slope: number; start: Phaser.Point; top: number; type: number; width: number; x: number; y: 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; static intersectsRectangle(line: Phaser.Line, rect: Phaser.Rectangle): boolean; static reflect(a: Phaser.Line, b: Phaser.Line): number; centerOn(x: number, y: number): Phaser.Line; clone(output: Phaser.Line): Phaser.Line; coordinatesOnLine(stepRate: number, results: any[]): any[]; fromAngle(x: number, y: number, angle: number, length: 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; midPoint(out?: Phaser.Point): Phaser.Point; pointOnLine(x: number, y: number): boolean; pointOnSegment(x: number, y: number): boolean; random(out?: Phaser.Point): Phaser.Point; reflect(line: Phaser.Line): number; rotate(angle: number, asDegrees?: boolean): Phaser.Line; rotateAround(x: number, y: number, angle: number, asDegrees?: boolean): Phaser.Line; setTo(x1?: number, y1?: number, x2?: number, y2?: number): Phaser.Line; } class LinkedList { first: any; last: any; next: any; prev: any; total: number; add(item: any): any; callAll(callback: Function): void; remove(item: any): void; reset(): void; } class Loader { constructor(game: Phaser.Game); static PHYSICS_LIME_CORONA_JSON: number; static PHYSICS_PHASER_JSON: number; static TEXTURE_ATLAS_JSON_ARRAY: number; static TEXTURE_ATLAS_JSON_HASH: number; static TEXTURE_ATLAS_XML_STARLING: number; static TEXTURE_ATLAS_JSON_PYXEL: number; baseURL: string; cache: Phaser.Cache; crossOrigin: boolean | string; enableParallel: boolean; game: Phaser.Game; hasLoaded: boolean; isLoading: boolean; maxParallelDownloads: number; onFileStart: Phaser.Signal; onFileComplete: Phaser.Signal; onFileError: Phaser.Signal; onLoadComplete: Phaser.Signal; onLoadStart: Phaser.Signal; onPackComplete: Phaser.Signal; path: string; preloadSprite: any; progress: number; progressFloat: number; resetLocked: boolean; useXDomainRequest: boolean; asyncComplete(file: any, errorMessage?: string): void; addSyncPoint(type: string, key: string): Phaser.Loader; addToFileList(type: string, key: string, url?: string, properties?: any, overwrite?: boolean, extension?: string): Phaser.Loader; atlas(key: string, textureURL?: string, atlasURL?: string, atlasData?: any, format?: number): Phaser.Loader; atlasJSONArray(key: string, textureURL?: string, atlasURL?: string, atlasData?: any): Phaser.Loader; atlasJSONHash(key: string, textureURL?: string, atlasURL?: string, atlasData?: any): Phaser.Loader; atlasXML(key: string, textureURL?: string, atlasURL?: string, atlasData?: any): Phaser.Loader; audio(key: string, urls: string | string[] | any, autoDecode?: boolean): Phaser.Loader; audiosprite(key: string, urls: string[], jsonURL?: string, jsonData?: string | any, autoDecode?: boolean): Phaser.Loader; binary(key: string, url?: string, callback?: Function, callbackContext?: any): Phaser.Loader; bitmapFont(key: string, textureURL?: string, atlasURL?: string, atlasData?: any, xSpacing?: number, ySpacing?: number): Phaser.Loader; checkKeyExists(type: string, key: string): boolean; csvLoadComplete(file: any, xhr: XMLHttpRequest): void; fileComplete(file: any, xhr: XMLHttpRequest): void; fileError(file: any, xhr: XMLHttpRequest, reason: string): void; finishedLoading(abnormal?: boolean): void; getAsset(type: string, key: string): any; getAssetIndex(type: string, key: string): number; getAudioURL(urls: any[]): void; image(key: string, url?: string, overwrite?: boolean): Phaser.Loader; images(keys: string[], urls?: string[]): Phaser.Loader; json(key: string, url?: string, overwrite?: boolean): Phaser.Loader; jsonLoadComplete(file: any, xhr: XMLHttpRequest): void; loadAudioTag(file: any): void; loadFile(file: any): void; loadImageTag(file: any): void; pack(key: string, url?: string, data?: any, callbackContext?: any): Phaser.Loader; parseXml(data: string): XMLDocument; physics(key: string, url?: string, data?: any, format?: string): Phaser.Loader; processLoadQueue(): void; processPack(pack: any): void; removeAll(): void; removeFile(type: string, key: string): void; replaceInFileList(type: string, key: string, url: string, properties: any): void; reset(hard?: boolean, clearEvents?: boolean): void; resize(): void; script(key: string, url?: String, callback?: Function, callbackContext?: any): Phaser.Loader; shader(key: string, url?: String, overwrite?: boolean): Phaser.Loader; setPreloadSprite(sprite: Phaser.Sprite | Phaser.Image, direction?: number): void; spritesheet(key: string, url: string, frameWidth: number, frameHeight: number, frameMax?: number, margin?: number, spacing?: number): Phaser.Loader; start(): void; text(key: string, url?: string, overwrite?: boolean): Phaser.Loader; tilemap(key: string, url?: string, data?: any, format?: number): Phaser.Loader; totalLoadedFiles(): number; totalLoadedPacks(): number; totalQueuedFiles(): number; totalQueuedPacks(): number; transformUrl(url: string, file?: any): string; updateProgress(): void; video(key: string, urls: string | string[] | any, loadEvent?: string, asBlob?: boolean): Phaser.Loader; withSyncPoint(callback: Function, callbackContext?: any): Phaser.Loader; xml(key: string, url?: string, overwrite?: boolean): Phaser.Loader; xhrLoad(file: any, url: string, type: string, onload: Function, onerror?: Function): void; xhrLoadWithXDR(file: any, url: string, type: string, onload: Function, onerror?: Function): void; xmlLoadComplete(file: any, xhr: XMLHttpRequest): void; } class LoaderParser { static bitmapFont(xml: any, baseTexture: PIXI.BaseTexture, xSpacing?: number, ySpacing?: number): any; static xmlBitmapFont(xml: any, baseTexture: PIXI.BaseTexture, xSpacing?: number, ySpacing?: number): any; static jsonBitmapFont(json: any, baseTexture: PIXI.BaseTexture, xSpacing?: number, ySpacing?: number): any; } class Matrix extends PIXI.Matrix { a: number; b: number; c: number; d: number; tx: number; ty: number; type: number; constructor(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number); apply(pos: Phaser.Point, newPos?: Phaser.Point): Phaser.Point; applyInverse(pos: Phaser.Point, newPos?: Phaser.Point): Phaser.Point; clone(output?: Phaser.Matrix): Phaser.Matrix; copyFrom(matrix: Phaser.Matrix): Phaser.Matrix; copyTo(matrix: Phaser.Matrix): Phaser.Matrix; fromArray(array: number[]): Phaser.Matrix; setTo(a: number, b: number, c: number, d: number, tx: number, ty: number): Phaser.Matrix; toArray(transpose?: boolean, array?: number[]): number[]; translate(x: number, y: number): Phaser.Matrix; scale(x: number, y: number): Phaser.Matrix; rotate(angle: number): Phaser.Matrix; append(matrix: Phaser.Matrix): Phaser.Matrix; identity(): Phaser.Matrix; } class Math { static angleBetween(x1: number, y1: number, x2: number, y2: number): number; static angleBetweenPoints(point1: Phaser.Point, point2: Phaser.Point): number; static angleBetweenY(x1: number, y1: number, x2: number, y2: number): number; static angleBetweenPointsY(point1: Phaser.Point, point2: Phaser.Point): number; static average(...numbers: number[]): number; static bernstein(n: number, i: number): number; static between(min: number, max: number): number; static bezierInterpolation(v: number[], k: number): number; static catmullRom(p0: number, p1: number, p2: number, p3: number, t: number): number; static catmullRomInterpolation(v: number[], k: number): number; static ceilTo(value: number, place?: number, base?: number): number; static clamp(x: number, a: number, b: number): number; static clampBottom(x: number, a: number): number; static degToRad(degrees: number): number; static difference(a: number, b: number): number; static distance(x1: number, y1: number, x2: number, y2: number): number; static distanceSq(x1: number, y1: number, x2: number, y2: number): number; static distancePow(xy: number, y1: number, x2: number, y2: number, pow?: number): number; static factorial(value: number): number; static floorTo(value: number, place: number, base: number): number; static fuzzyCeil(val: number, epsilon?: number): boolean; static fuzzyEqual(a: number, b: number, epsilon?: number): boolean; static fuzzyLessThan(a: Number, b: number, epsilon?: number): boolean; static fuzzyFloor(val: number, epsilon?: number): boolean; static fuzzyGreaterThan(a: number, b: number, epsilon?: number): boolean; static fuzzyLessThan(a: number, b: number, epsilon?: number): boolean; static isEven(n: number): boolean; static isOdd(n: number): boolean; static linear(p0: number, p1: number, t: number): number; static linearInterpolation(v: number[], k: number): number; static mapLinear(x: number, a1: number, a2: number, b1: number, b2: number): number; static max(...numbers: number[]): number; static maxAdd(value: number, amount: number, max: number): number; static maxProperty(...numbers: number[]): number; static min(...numbers: number[]): number; static minProperty(...numbers: number[]): number; static minSub(value: number, amount: number, min: number): number; static normalizeAngle(angle: number, radians?: boolean): number; static percent(a: number, b: number, base?: number): number; static p2px(v: number): number; static PI2: number; static radToDeg(radians: number): number; static reverseAngle(angleRed: number): number; static rotateToAngle(currentAngle: number, targetAngle: number, lerp?: number): number; static roundAwayFromZero(value: number): number; static roundTo(value: number, place?: number, base?: number): number; static shear(n: number): number; static sign(x: number): number; static sinCosGenerator(length: number, sinAmplitude?: number, cosAmplitude?: number, frequency?: number): { sin: number[]; cos: number[]; }; static smootherstep(x: number, min: number, max: number): number; static smoothstep(x: number, min: number, max: number): number; static snapTo(input: number, gap: number, start?: number): number; static snapToCeil(input: number, gap: number, start?: number): number; static snapToFloor(input: number, gap: number, start?: number): number; static within(a: number, b: number, tolerance: number): boolean; static wrap(value: number, min: number, max: number): number; static wrapAngle(angle: number, radians?: boolean): number; static wrapValue(value: number, amount: number, max: number): number; } interface WheelEventProxy { bindEvent(event: any): WheelEventProxy; type: string; deltaMode: number; deltaX: number; deltaY: number; deltaZ: number; } class Mouse { constructor(game: Phaser.Game); static NO_BUTTON: number; static LEFT_BUTTON: number; static MIDDLE_BUTTON: number; static RIGHT_BUTTON: number; static BACK_BUTTON: number; static FORWARD_BUTTON: number; static WHEEL_DOWN: number; static WHEEL_UP: number; button: number; callbackContext: any; capture: boolean; enabled: boolean; event: MouseEvent; game: Phaser.Game; input: Phaser.Input; locked: boolean; mouseDownCallback: (event: MouseEvent) => void; mouseOutCallback: (event: MouseEvent) => void; mouseOverCallback: (event: MouseEvent) => void; mouseUpCallback: (event: MouseEvent) => void; mouseWheelCallback: (event: MouseEvent) => void; _onMouseDown: (event: MouseEvent) => void; _onMouseMove: (event: MouseEvent) => void; _onMouseUp: (event: MouseEvent) => void; _onMouseOut: (event: MouseEvent) => void; _onMouseOver: (event: MouseEvent) => void; _onMouseWheel: (event: MouseEvent) => void; _wheelEvent: WheelEventProxy; pointerLock: Phaser.Signal; stopOnGameOut: boolean; wheelDelta: number; onMouseDown(event: MouseEvent): void; onMouseMove(event: MouseEvent): void; onMouseOut(event: MouseEvent): void; onMouseOver(event: MouseEvent): void; onMouseUp(event: MouseEvent): void; onMouseUpGlobal(event: MouseEvent): void; onMouseWheel(event: MouseEvent): void; pointerLockChange(event: MouseEvent): void; releasePointerLock(): void; requestPointerLock(): void; start(): void; stop(): void; } class MSPointer { constructor(game: Phaser.Game); button: number; capture: boolean; callbackContext: any; event: MSPointerEvent; game: Phaser.Game; input: Phaser.Input; onPointerDown: (event: MSPointerEvent) => void; onPointerMove: (event: MSPointerEvent) => void; onPointerUp: (event: MSPointerEvent) => void; mouseDownCallback: (event: MSPointerEvent) => void; mouseMoveCallback: (event: MSPointerEvent) => void; mouseUpCallback: (event: MSPointerEvent) => void; pointerDownCallback: (event: MSPointerEvent) => void; pointerMoveCallback: (event: MSPointerEvent) => void; pointerUpCallback: (event: MSPointerEvent) => void; start(): void; stop(): void; } class Net { constructor(game: Phaser.Game); game: Phaser.Game; checkDomainName(domain: string): boolean; decodeURI(value: string): string; getHostName(): string; getQueryString(parameter?: string): string; updateQueryString(key: string, value: any, redirect?: boolean, url?: string): string; } class Particle extends Phaser.Sprite { constructor(game: Phaser.Game, x: number, y: number, key?: any, frame?: any); fresh: boolean; onEmit(): void; reset(x: number, y: number, health?: number): Phaser.Particle; setAlphaData(data: any[]): void; setScaleData(data: any[]): void; update(): void; } class Particles { constructor(game: Phaser.Game); emitters: any; game: Phaser.Game; 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); alphaData: any[]; autoAlpha: boolean; autoScale: boolean; angle: number; angularDrag: number; bottom: number; bounce: Phaser.Point; emitX: number; emitY: number; exists: boolean; frequency: number; gravity: number; group: Phaser.Group; height: number; left: number; lifespan: number; maxParticles: number; maxParticleScale: number; maxParticleSpeed: Phaser.Point; maxRotation: number; minParticleScale: number; minParticleSpeed: Phaser.Point; minRotation: number; name: string; on: boolean; particleAnchor: Phaser.Point; particleBringToTop: boolean; particleSendToBack: boolean; particleClass: any; particleDrag: Phaser.Point; physicsType: number; position: Phaser.Point; right: number; scaleData: any[]; top: number; type: number; width: number; x: number; y: number; at(object: any): Phaser.Particles.Arcade.Emitter; emitParticle(x?: number, y?: number, key?: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture, frame?: string | number): boolean; explode(lifespan?: number, quantity?: number): Phaser.Particles.Arcade.Emitter; flow(lifespan?: number, frequency?: number, quantity?: number, total?: number, immediate?: boolean): Phaser.Particles.Arcade.Emitter; kill(): Phaser.Particles.Arcade.Emitter; makeParticles(keys: any, frames?: any, quantity?: number, collide?: boolean, collideWorldBounds?: boolean): Phaser.Particles.Arcade.Emitter; reset(x: number, y: number, health?: number): Phaser.Particles; setAlpha(min?: number, max?: number, rate?: number, ease?: (k: number) => number, yoyo?: boolean): Phaser.Particles.Arcade.Emitter; setRotation(min?: number, max?: number): Phaser.Particles.Arcade.Emitter; setScale(minX?: number, maxX?: number, minY?: number, maxY?: number, rate?: number, ease?: (k: number) => number, yoyo?: boolean): Phaser.Particles.Arcade.Emitter; setSize(width: number, height: number): Phaser.Particles.Arcade.Emitter; setXSpeed(min: number, max: number): Phaser.Particles.Arcade.Emitter; setYSpeed(min: number, max: number): Phaser.Particles.Arcade.Emitter; start(explode?: boolean, lifespan?: number, frequency?: number, quantity?: number, forceQuantity?: boolean): Phaser.Particles.Arcade.Emitter; update(): void; revive(): Phaser.Particles.Arcade.Emitter; } } } class Physics { constructor(game: Phaser.Game, config?: any); static ARCADE: number; static P2JS: number; static NINJA: number; static BOX2D: number; static CHIPMUNK: number; static MATTERJS: number; arcade: Phaser.Physics.Arcade; config: any; game: Phaser.Game; ninja: Phaser.Physics.Ninja; p2: Phaser.Physics.P2; box2d: any; clear(): void; destroy(): void; enable(object: any, system?: number, debug?: boolean): void; parseConfig(): void; preUpdate(): void; reset(): void; setBoundsToWorld(): void; startSystem(system: number): void; update(): void; } export class Video { game: Phaser.Game; key: string; video: HTMLVideoElement; baseTexture: PIXI.BaseTexture; texture: PIXI.Texture; textureFrame: Phaser.Frame; type: number; disableTextureUpload: boolean; dirty: boolean; currentTime: number; duration: number; progress: number; mute: boolean; paused: boolean; volume: boolean; playbackRate: boolean; playing: boolean; loop: boolean; width: number; height: number; videoStream: any; isStreaming: boolean; snapshot: Phaser.BitmapData; timeout: number; retryLimit: number; retry: number; retryInterval: number; onAccess: Phaser.Signal; onError: Phaser.Signal; onPlay: Phaser.Signal; onComplete: Phaser.Signal; onUpdate: Phaser.Signal; onTimeout: Phaser.Signal; touchLocked: boolean; complete: () => void; constructor(game: Phaser.Game, key?: string, url?: string); add(object: Phaser.Sprite | Phaser.Sprite[] | Phaser.Image | Phaser.Image[]): Phaser.Video; addToWorld(x?: number, y?: number, anchorX?: number, anchorY?: Number, scaleX?: number, scaleY?: number): Phaser.Image; createVideoFromBlob(blob: Blob): Phaser.Video; startMediaStream(captureAudio?: boolean, width?: number, height?: number): Phaser.Video; createVideoFromURL(url: string, autoplay?: boolean): Phaser.Video; changeSource(src: string, autoplay?: boolean): Phaser.Video; connectToMediaStram(video: any, stream: any): Phaser.Video; destroy(): void; play(loop?: boolean, playbackRate?: number): Phaser.Video; playHandler(): void; render(): void; removeVideoElement(): void; resizeFrame(parent: any, width: number, height: number): void; setTouchLock(): void; grab(clear?: boolean, alpha?: number, blendMode?: string): Phaser.BitmapData; stop(): void; unlock(): boolean; updateTexture(event?: any, width?: number, height?: number): void; } module Physics { class Arcade { static SORT_NONE: number; static LEFT_RIGHT: number; static RIGHT_LEFT: number; static TOP_BOTTOM: number; static BOTTOM_TOP: number; static OVERLAP_BIAS: number; static TILE_BIAS: number; constructor(game: Phaser.Game); bounds: Phaser.Rectangle; checkCollision: { up?: boolean; down?: boolean; left?: boolean; right?: boolean; }; forceX: boolean; game: Phaser.Game; gravity: Phaser.Point; quadTree: Phaser.QuadTree; maxObjects: number; maxLevels: number; skipQuadTree: boolean; sortDirection: number; accelerationFromRotation(rotation: number, speed?: number, point?: Phaser.Point): Phaser.Point; accelerateToObject(displayObject: any, destination: any, speed?: number, xSpeedMax?: number, ySpeedMax?: number): number; accelerateToPointer(displayObject: any, pointer?: Phaser.Pointer, speed?: number, xSpeedMax?: number, ySpeedMax?: number): number; accelerateToXY(displayObject: any, x: number, y: number, speed?: number, xSpeedMax?: number, ySpeedMax?: number): number; angleBetween(source: any, target: any, world?: boolean): number; angleToPointer(displayObject: any, pointer?: Phaser.Pointer, world?: boolean): number; angleToXY(displayObject: any, x: number, y: number, world?: boolean): number; collide(object1: any, object2?: any, collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean; computeVelocity(axis: number, body: Phaser.Physics.Arcade.Body, velocity: number, acceleration: number, drag: number, max?: number): number; distanceBetween(source: any, target: any, world?: boolean): number; distanceToPointer(displayObject: any, pointer?: Phaser.Pointer, world?: boolean): number; distanceToXY(displayObject: any, x: number, y: number, world?: boolean): number; enable(object: any, children?: Boolean): void; enableBody(object: any): void; getObjectsAtLocation(x: number, y: number, group: Phaser.Group, callback?: (callbackArg: any, object: any) => void, callbackContext?: any, callbackArg?: any): Sprite[]; getOverlapX(body1: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body): number; getOverlapY(body1: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body): number; intersects(body1: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body): boolean; moveToObject(displayObject: any, destination: any, speed?: number, maxTime?: number): number; moveToPointer(displayObject: any, speed?: number, pointer?: Phaser.Pointer, maxTime?: number): number; moveToXY(displayObject: any, x: number, y: number, speed?: number, maxTime?: number): number; overlap(object1: any, object2: any, overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean; processTileSeparationX(body: Phaser.Physics.Arcade.Body, x: number): boolean; processTileSeparationY(body: Phaser.Physics.Arcade.Body, y: number): void; setBounds(x: number, y: number, width: number, height: number): void; setBoundsToWorld(): void; separate(body1: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body, processCallback?: Function, callbackContext?: any, overlapOnly?: boolean): boolean; separateX(body1: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body, overlapOnly: boolean): boolean; separateY(body1: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body, overlapOnly: boolean): boolean; separateTile(i: number, body: Phaser.Physics.Arcade.Body, tile: Phaser.Tile): boolean; sort(group: Phaser.Group): void; tileCheckX(body: Phaser.Physics.Arcade.Body, tile: Phaser.Tile): number; tileCheckY(body: Phaser.Physics.Arcade.Body, tile: Phaser.Tile): number; updateMotion(body: Phaser.Physics.Arcade.Body): void; velocityFromAngle(angle: number, speed?: number, point?: Phaser.Point): Phaser.Point; velocityFromRotation(rotation: number, speed?: number, point?: Phaser.Point): Phaser.Point; } module Arcade { class Body { constructor(sprite: Phaser.Sprite); acceleration: Phaser.Point; allowGravity: boolean; allowRotation: boolean; angle: number; angularAcceleration: number; angularDrag: number; angularVelocity: number; blocked: FaceChoices; bottom: number; bounce: Phaser.Point; center: Phaser.Point; checkCollision: FaceChoices; collideWorldBounds: boolean; customSeparateX: boolean; customSeparateY: boolean; deltaMax: Phaser.Point; dirty: boolean; drag: Phaser.Point; embedded: boolean; enable: boolean; facing: number; friction: Phaser.Point; game: Phaser.Game; gravity: Phaser.Point; halfWidth: number; halfHeight: number; height: number; immovable: boolean; isCircle: boolean; isMoving: boolean; mass: number; maxAngular: number; maxVelocity: Phaser.Point; moves: boolean; movementCallback: any; movementCallbackContext: any; newVelocity: Phaser.Point; offset: Phaser.Point; onCollide: Phaser.Signal; onMoveComplete: Phaser.Signal; onOverlap: Phaser.Signal; onWorldBounds: Phaser.Signal; overlapX: number; overlapY: number; phase: number; position: Phaser.Point; preRotation: number; prev: Phaser.Point; radius: number; right: number; rotation: number; skipQuadTree: boolean; sourceWidth: number; sourceHeight: number; speed: number; sprite: Phaser.Sprite; stopVelocityOnCollide: boolean; syncBounds: boolean; tilePadding: Phaser.Point; touching: FaceChoices; type: number; wasTouching: FaceChoices; width: number; worldBounce: Phaser.Point; velocity: Phaser.Point; x: number; y: number; checkWorldBounds(): void; deltaX(): number; deltaY(): number; deltaZ(): number; deltaAbsX(): number; deltaAbsY(): number; destroy(): void; getBounds(obj: any): any; hitTest(x: number, y: number): boolean; moveFrom(duration: number, speed?: number, direction?: number): boolean; moveTo(duration: number, distance: number, direction?: number): boolean; onFloor(): boolean; onWall(): boolean; preUpdate(): void; postUpdate(): void; render(context: any, body: Phaser.Physics.Arcade.Body, color?: string, filled?: boolean): void; renderBodyInfo(debug: Phaser.Utils.Debug, body: Phaser.Physics.Arcade.Body): void; reset(x: number, y: number): void; setCircle(radius: number, offsetX?: number, offsetY?: number): void; setSize(width: number, height: number, offsetX?: number, offsetY?: number): void; updateBounds(): boolean; } class FaceChoices { none: boolean; any: boolean; up: boolean; down: boolean; left: boolean; right: boolean; } } class Ninja { constructor(game: Phaser.Game); game: Phaser.Game; gravity: number; bounds: Phaser.Rectangle; maxObjects: number; maxLevels: number; quadTree: Phaser.QuadTree; time: Phaser.Time; clearTilemapLayerBodies(map: Phaser.Tilemap, layer: any): void; collide(object1: any, object2: any, collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean; convertTilemap(map: Phaser.Tilemap, layer: any, slopeMap: any): Phaser.Physics.Ninja.Tile[]; enableAABB(object: any, children?: boolean): void; enableCircle(object: any, radius: number, children?: boolean): void; enableTile(object: any, id: number, children?: boolean): void; enable(object: any, type?: number, id?: number, radius?: number, children?: boolean): void; enableBody(object: any, type?: number, id?: number, radius?: number): void; overlap(object1: any, object2: any, overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean; separate(body1: Phaser.Physics.Ninja.Body, body2: Phaser.Physics.Ninja.Body, processCallback?: Function, callbackContext?: any, overlapOnly?: boolean): boolean; setBounds(x: number, y: number, width: number, height: number): void; setBoundsToWorld(): void; } module Ninja { class Body { constructor(system: Phaser.Physics.Ninja, sprite: Phaser.Sprite, type?: number, id?: number, radius?: number, x?: number, y?: number, width?: number, height?: number); aabb: Phaser.Physics.Ninja.AABB; angle: number; bottom: number; bounce: number; checkCollision: Phaser.Physics.Arcade.FaceChoices; circle: Phaser.Physics.Ninja.Circle; collideWorldBounds: boolean; drag: number; facing: number; friction: number; game: Phaser.Game; gravityScale: number; height: number; immovable: boolean; maxSpeed: number; right: number; sprite: Phaser.Sprite; system: Phaser.Physics.Ninja; tile: Phaser.Physics.Ninja.Tile; touching: Phaser.Physics.Arcade.FaceChoices; type: number; shape: any; speed: number; velocity: Phaser.Point; wasTouching: Phaser.Physics.Arcade.FaceChoices; width: number; x: number; y: number; deltaAbsX(): number; deltaAbsY(): number; deltaX(): number; deltaY(): number; destroy(): void; setZeroVelocity(): void; moveTo(speed: number, angle: number): void; moveFrom(speed: number, angle: number): void; moveLeft(speed: number): void; moveRight(speed: number): void; moveUp(speed: number): void; moveDown(speed: number): void; poseUpdate(): void; preUpdate(): void; render(context: any, body: Phaser.Physics.Ninja.Body, color?: string, filled?: boolean): void; reset(): void; } class AABB { constructor(body: Phaser.Physics.Ninja.Body, x: number, y: number, width: number, height: number); static COL_NONE: number; static COL_AXIS: number; static COL_OTHER: number; aabbTileProjections: any; body: Phaser.Physics.Ninja.Body; height: number; oldPos: Phaser.Point; pos: Phaser.Point; system: Phaser.Physics.Ninja; width: number; velocity: Phaser.Point; xw: number; yw: number; collideWorldBounds(): void; collideAABBVsAABB(aabb: Phaser.Physics.Ninja.AABB): boolean; collideAABBVsTile(tile: Phaser.Physics.Ninja.Tile): boolean; destroy(): void; integrate(): void; render(context: any, xOffset: number, yOffset: number, color: string, filled: boolean): void; reportCollision(px: number, py: number, dx: number, dy: number): void; reportCollisionVsWorld(px: number, py: number, dx: number, dy: number, obj: any): void; reportCollisionVsBody(px: number, py: number, dx: number, dy: number, obj: any): void; resolveTile(x: number, y: number, body: Phaser.Physics.Ninja.AABB, tile: Phaser.Physics.Ninja.Tile): boolean; reverse(): void; } class Circle { constructor(body: Phaser.Physics.Ninja.Body, x: number, y: number, radius: number); COL_NONE: number; COL_AXIS: number; COL_OTHER: number; body: Phaser.Physics.Ninja.Body; circleTileProjections: { [index: number]: ((x: number, y: number, oH: number, oV: number, obj: Phaser.Physics.Ninja.Circle, t: Phaser.Physics.Ninja.Tile) => number); }; oldPos: Phaser.Point; height: number; pos: Phaser.Point; radius: number; system: Phaser.Physics.Ninja; type: number; velocity: Phaser.Point; width: number; xw: number; yw: number; collideCircleVsTile(tile: Phaser.Physics.Ninja.Tile): boolean; collideWorldBounds(): void; destroy(): void; distance(dest: number, round?: boolean): number; integrate(): void; render(context: any, xOffset: number, yOffset: number, color: string, filled: boolean): void; reportCollisionVsWorld(px: number, py: number, dx: number, dy: number, obj: any): void; reportCollisionVsBody(px: number, py: number, dx: number, dy: number, obj: any): void; resolveCircleTile(x: number, y: number, oH: number, oV: number, obj: Phaser.Physics.Ninja.Circle, t: Phaser.Physics.Ninja.Tile): boolean; } enum TileType { TYPE_EMPTY, TYPE_FULL, TYPE_45DEG, TYPE_CONCAVE, TYPE_CONVEX, TYPE_22DEGs, TYPE_22DEGb, TYPE_67DEGs, TYPE_67DEGb, TYPE_HALF } class Tile { constructor(body: Phaser.Physics.Ninja.Body, x: number, y: number, width: number, height: number, type?: number); body: Phaser.Physics.Ninja.Body; bottom: number; flipped: boolean; height: number; id: number; oldpos: Phaser.Point; pos: Phaser.Point; right: number; rotation: number; system: Phaser.Physics.Ninja; type: Phaser.Physics.Ninja.TileType; velocity: Phaser.Point; width: number; xw: number; yw: number; x: number; y: number; clear(): void; collideWorldBounds(): void; destroy(): void; integrate(): void; reportCollisionVsWorld(px: number, py: number, dx: number, dy: number, obj: any): void; setType(id: number): number; } } class P2 { constructor(game: Phaser.Game, config?: any); applyDamping: boolean; applyGravity: boolean; applySpringForces: boolean; boundsCollidesWith: Phaser.Physics.P2.Body[]; boundsCollisionGroup: Phaser.Physics.P2.CollisionGroup; config: any; callbackContext: any; collisionGroups: Phaser.Physics.P2.CollisionGroup[]; contactMaterial: Phaser.Physics.P2.ContactMaterial; emitImpactEvent: boolean; everythingCollisionGroup: Phaser.Physics.P2.CollisionGroup; frameRate: number; friction: number; game: Phaser.Game; gravity: Phaser.Physics.P2.InversePointProxy; materials: Phaser.Physics.P2.Material[]; nothingCollisionGroup: Phaser.Physics.P2.CollisionGroup; onBodyAdded: Phaser.Signal; onBodyRemoved: Phaser.Signal; onBeginContact: Phaser.Signal; onConstraintAdded: Phaser.Signal; onConstraintRemoved: Phaser.Signal; onContactMaterialAdded: Phaser.Signal; onContactMaterialRemoved: Phaser.Signal; onEndContact: Phaser.Signal; onSpringAdded: Phaser.Signal; onSpringRemoved: Phaser.Signal; paused: boolean; postBroaddphaseCallback: Function; restitution: number; solveConstraints: boolean; time: any; total: number; useElapsedTime: boolean; walls: { left?: Phaser.Physics.P2.Body; right?: Phaser.Physics.P2.Body; top?: Phaser.Physics.P2.Body; bottom?: Phaser.Physics.P2.Body; }; world: p2.World; addBody(body: Phaser.Physics.P2.Body): boolean; addContactMaterial(material: Phaser.Physics.P2.ContactMaterial): Phaser.Physics.P2.ContactMaterial; addConstraint(constraint: T): T; addSpring(spring: Phaser.Physics.P2.Spring): Phaser.Physics.P2.Spring; beginContactHandler(event: any): void; clear(): void; clearTilemapLayerBodies(map: Phaser.Tilemap, layer?: any): void; convertCollisionObjects(map: Phaser.Tilemap, layer?: any, addToWorld?: boolean): Phaser.Physics.P2.Body[]; convertTilemap(map: Phaser.Tilemap, layer?: any, addToWorld?: Boolean, optimize?: boolean): Phaser.Physics.P2.Body[]; createBody(x: number, y: number, mass: number, addToWorld?: boolean, options?: p2.BodyOptions, data?: number[][]): Phaser.Physics.P2.Body; createBody(x: number, y: number, mass: number, addToWorld?: boolean, options?: p2.BodyOptions, data?: number[]): Phaser.Physics.P2.Body; createCollisionGroup(group?: Phaser.Group): Phaser.Physics.P2.CollisionGroup; createCollisionGroup(group?: Phaser.Sprite): Phaser.Physics.P2.CollisionGroup; createContactMaterial(materialA: Phaser.Physics.P2.Material, materialB: Phaser.Physics.P2.Material, options?: p2.ContactMaterialOptions): Phaser.Physics.P2.ContactMaterial; createDistanceConstraint(bodyA: any, bodyB: any, distance: number, localAnchorA?: number[], localAnchorB?: number[], maxForce?: number): Phaser.Physics.P2.DistanceConstraint; createGearConstraint(bodyA: any, bodyB: any, angle?: number, ratio?: number): Phaser.Physics.P2.GearConstraint; createLockConstraint(bodyA: any, bodyB: any, offset?: number[], angle?: number, maxForce?: number): Phaser.Physics.P2.LockConstraint; createMaterial(name?: string, body?: Phaser.Physics.P2.Body): Phaser.Physics.P2.Material; createParticle(x: number, y: number, mass: number, addToWorld?: boolean, options?: p2.BodyOptions, data?: number[][]): Phaser.Physics.P2.Body; createParticle(x: number, y: number, mass: number, addToWorld?: boolean, options?: p2.BodyOptions, data?: number[]): Phaser.Physics.P2.Body; createPrismaticConstraint(body: any, bodyB: any, lockRotation?: boolean, anchorA?: number[], anchorB?: number[], axis?: Float32Array, maxForce?: number): Phaser.Physics.P2.PrismaticConstraint; createRevoluteConstraint(bodyA: any, pivotA: number[], bodyB: any, pivotB: number[], maxForce?: number, worldPivot?: number[]): Phaser.Physics.P2.RevoluteConstraint; createRotationalSpring(bodyA: any, bodyB: any, restAngle?: number, stiffness?: number, damping?: number): p2.RotationalSpring; createSpring(bodyA: any, bodyB: any, restLength?: number, stiffness?: number, damping?: number, worldA?: number[], worldB?: number[], localA?: number[], localB?: number[]): Phaser.Physics.P2.Spring; destroy(): void; enable(object: any, debug?: boolean, children?: boolean): void; enableBody(object: any, debug: boolean): void; endContactHandler(event: any): void; getBodies(): Phaser.Physics.P2.Body[]; getBody(object: any): Phaser.Physics.P2.Body; getConstraints(): p2.Constraint[]; getSprings(): Phaser.Physics.P2.Spring[]; getContactMaterial(materialA: Phaser.Physics.P2.Material, materialB: Phaser.Physics.P2.Material): Phaser.Physics.P2.ContactMaterial; hitTest(worldPoint: Phaser.Point, bodies?: any[], precision?: number, filterStatic?: boolean): Phaser.Physics.P2.Body[]; mpx(v: number): number; mpxi(v: number): number; pause(): void; preUpdate(): void; pxm(v: number): number; pxmi(v: number): number; removeBody(body: Phaser.Physics.P2.Body): Phaser.Physics.P2.Body; removeBodyNextStep(body: Phaser.Physics.P2.Body): void; removeConstraint(constraint: T): T; removeContactMaterial(material: Phaser.Physics.P2.ContactMaterial): Phaser.Physics.P2.ContactMaterial; removeSpring(spring: Phaser.Physics.P2.Spring): Phaser.Physics.P2.Spring; reset(): void; resume(): void; setBounds(x: number, y: number, width: number, height: number, left?: Boolean, right?: boolean, top?: boolean, bottom?: boolean, setCollisionGroup?: boolean): void; setBoundsToWorld(left?: boolean, right?: boolean, top?: boolean, bottom?: boolean, setCollisionGroup?: boolean): void; setCollisionGroup(object: any, group: Phaser.Physics.P2.CollisionGroup): void; setImpactEvents(state: boolean): void; setMaterial(material: Phaser.Physics.P2.Material, bodies?: Phaser.Physics.P2.Body[]): void; setPostBroadphaseCallback(callback: Function, context: any): void; setWorldMaterial(material: Phaser.Physics.P2.Material, left?: boolean, right?: boolean, top?: boolean, bottom?: boolean): void; toJSON(): any; update(): void; updateBoundsCollisionGroup(setCollisionGroup?: boolean): void; } module P2 { class Body { static DYNAMIC: number; static STATIC: number; static KINEMATIC: number; constructor(game: Phaser.Game, sprite?: Phaser.Sprite, x?: number, y?: number, mass?: number); allowSleep: boolean; angle: number; angularDamping: number; angularForce: number; angularVelocity: number; collidesWith: Phaser.Physics.P2.CollisionGroup[]; collideWorldBounds: boolean; damping: number; data: p2.Body; debug: boolean; debugBody: Phaser.Physics.P2.BodyDebug; dynamic: boolean; fixedRotation: boolean; force: Phaser.Physics.P2.InversePointProxy; kinematic: boolean; game: Phaser.Game; gravity: Phaser.Point; id: number; inertia: number; mass: number; motionState: number; offset: Phaser.Point; onBeginContact: Phaser.Signal; onEndContact: Phaser.Signal; rotation: number; removeNextStep: boolean; sprite: Phaser.Sprite; sleepSpeedLimit: number; static: boolean; type: number; velocity: Phaser.Physics.P2.InversePointProxy; world: Phaser.Physics.P2; x: number; y: number; addToWorld(): void; addCapsule(length: number, radius: number, offsetX?: number, offsetY?: number, rotation?: number): p2.Capsule; addCircle(radius: number, offsetX?: number, offsetY?: number, rotation?: number): p2.Circle; addFixture(fixtureData: string): p2.Shape[]; addLine(length: number, offsetX?: number, offsetY?: number, rotation?: number): p2.Line; addParticle(offsetX?: number, offsetY?: number, rotation?: number): p2.Particle; addPolygon(options: { optimalDecomp?: boolean; skipSimpleCheck?: boolean; removeCollinearPoints?: boolean; }, points: number[][]): boolean; addPhaserPolygon(key: string, object: string): Phaser.Physics.P2.FixtureList; addPlane(offsetX?: number, offsetY?: number, rotation?: number): p2.Plane; addRectangle(width: number, height: number, offsetX?: number, offsetY?: number, rotation?: number): p2.Rectangle; addShape(shape: p2.Shape, offsetX?: number, offsetY?: number, rotation?: number): p2.Shape; adjustCenterOfMass(): void; applyDamping(dt: number): void; applyForce(force: number[], worldX: number, worldY: number): void; applyImpulse(impulse: number[], worldX: number, worldY: number): void; applyImpulseLocal(impulse: number[], localX: number, localY: number): void; clearCollision(clearGroup?: boolean, cleanMask?: boolean, shape?: p2.Shape): void; clearShapes(): void; collides(group: any, callback?: Function, callbackContext?: any, shape?: p2.Shape): void; createBodyCallback(object: any, callback: Function, callbackContext: any): void; createGroupCallback(group: Phaser.Physics.P2.CollisionGroup, callback: Function, callbackContext: any): void; destroy(): void; getCollisionMask(): number; getVelocityAtPoint(result: number[], relativePoint: number[]): number[]; loadPolygon(key: string, object: string): boolean; moveBackward(speed: number): void; moveDown(speed: number): void; moveForward(speed: number): void; moveLeft(speed: number): void; moveRight(speed: number): void; moveUp(speed: number): void; preUpdate(): void; postUpdate(): void; removeCollisionGroup(group: any, clearCallback?: boolean, shape?: p2.Shape): void; removeFromWorld(): void; removeShape(shape: p2.Shape): boolean; reverse(speed: number): void; rotateLeft(speed: number): void; rotateRight(speed: number): void; reset(x: number, y: number, resetDamping?: boolean, resetMass?: boolean): void; shapeChanged(): void; setCircle(radius: number, offsetX?: number, offsetY?: number, rotation?: number): p2.Circle; setCollisionGroup(group: Phaser.Physics.P2.CollisionGroup, shape?: p2.Shape): void; setRectangle(width?: number, height?: number, offsetX?: number, offsetY?: number, rotation?: number): p2.Rectangle; setRectangleFromSprite(sprite: any): p2.Rectangle; setMaterial(material: Phaser.Physics.P2.Material, shape?: p2.Shape): void; setZeroDamping(): void; setZeroForce(): void; setZeroRotation(): void; setZeroVelocity(): void; toLocalFrame(out: number[], worldPoint: number[]): void; thrust(speed: number): void; thrustLeft(speed: number): void; thrustRight(speed: number): void; toWorldFrame(out: number[], localPoint: number[]): void; updateCollisionMask(shape?: p2.Shape): void; } class BodyDebug extends Phaser.Group { constructor(game: Phaser.Game, body: Phaser.Physics.P2.Body, settings: { pixelsPerLengthUnit?: number; debugPolygons?: boolean; lineWidth?: number; alpha?: number; }); body: Phaser.Physics.P2.Body; canvas: Phaser.Graphics; ppu: number; updateSpriteTransform(): void; draw(): void; } class CollisionGroup { constructor(bitmask: number); mask: number; } class ContactMaterial extends p2.ContactMaterial { } class DistanceConstraint extends p2.DistanceConstraint { constructor(world: Phaser.Physics.P2, bodyA: Phaser.Physics.P2.Body, bodyB: Phaser.Physics.P2.Body, distance: number, maxForce: number); game: Phaser.Game; world: Phaser.Physics.P2; } class FixtureList { constructor(list: any[]); flatten(array: any[]): any[]; getFixtures(keys: string): any[]; getFixtureByKey(key: string): any[]; getGroup(groupID: number): any[]; init(): void; parse(): void; setCategory(bit: number, fictureKey: string): void; setMask(bit: number, fixtureKey: string): void; setMaterial(material: any, fixtureKey: string): void; setSensor(value: boolean, fixtureKey: string): void; } class GearConstraint extends p2.GearConstraint { constructor(world: Phaser.Physics.P2, bodyA: Phaser.Physics.P2.Body, bodyB: Phaser.Physics.P2.Body, angle?: number, ratio?: number); game: Phaser.Game; world: Phaser.Physics.P2; } class InversePointProxy { constructor(world: Phaser.Physics.P2, destination: any); x: number; y: number; mx: number; my: number; } class LockConstraint extends p2.LockConstraint { constructor(world: Phaser.Physics.P2, bodyA: Phaser.Physics.P2.Body, bodyB: Phaser.Physics.P2.Body, offset?: number[], angle?: number, maxForce?: number); game: Phaser.Game; world: Phaser.Physics.P2; } class Material extends p2.Material { constructor(name: string); name: string; } class PointProxy { constructor(world: Phaser.Physics.P2, destination: any); x: number; y: number; mx: number; my: number; } class PrismaticConstraint extends p2.PrismaticConstraint { constructor(world: Phaser.Physics.P2, bodyA?: Phaser.Physics.P2.Body, bodyB?: Phaser.Physics.P2.Body, lockRotation?: boolean, anchorA?: number[], anchorB?: number[], axis?: number[], maxForce?: number); game: Phaser.Game; world: Phaser.Physics.P2; } class RevoluteConstraint extends p2.RevoluteConstraint { constructor(world: Phaser.Physics.P2, bodyA: Phaser.Physics.P2.Body, pivotA: number[], bodyB: Phaser.Physics.P2.Body, pivotB: number[], maxForce?: number); game: Phaser.Game; world: Phaser.Physics.P2; } class Spring { constructor(world: Phaser.Physics.P2, bodyA: Phaser.Physics.P2.Body, bodyB: Phaser.Physics.P2.Body, restLength?: number, stiffness?: number, damping?: number, worldA?: number[], worldB?: number[], localA?: number[], localB?: number[]); data: p2.LinearSpring; game: Phaser.Game; world: Phaser.Physics.P2; } } } class Plugin implements IStateCycle { constructor(game: Phaser.Game, parent: Phaser.PluginManager); active: boolean; game: Phaser.Game; hasPostRender: boolean; hasPostUpdate: boolean; hasPreUpdate: boolean; hasRender: boolean; hasUpdate: boolean; parent: PIXI.DisplayObject; visible: boolean; destroy(): void; postRender(): void; preUpdate(): void; render(): void; update(): void; } module Plugin { class SaveCPU extends Phaser.Plugin { renderOnFPS: number; renderOnPointerChange: boolean; forceRender(): void; } class AStar extends Phaser.Plugin { static VERSION: string; static COST_ORTHAGONAL: number; static COST_DIAGAONAL: number; static DISTANCE_MANHATTEN: string; static DISTANCE_EUCLIDIAN: string; constructor(parent: PIXI.DisplayObject); parent: PIXI.DisplayObject; version: string; findPath(startPoint: Phaser.Point, goalPoint: Phaser.Point): Phaser.Plugin.AStar.AStarPath; isWalkable(x: number, y: number): boolean; setAStarMap(map: Phaser.Tilemap, layerName: string, tilesetName: string): Phaser.Plugin.AStar; } module AStar { class AStarNode { constructor(x: number, y: number, isWalkable: boolean); x: number; y: number; g: number; h: number; f: number; parent: Phaser.Plugin.AStar.AStarNode; travelCost: number; walkable: boolean; } class AStarPath { constructor(nodes: Phaser.Plugin.AStar.AStarNode[], start: Phaser.Plugin.AStar.AStarNode, goal: Phaser.Plugin.AStar.AStarNode); nodes: Phaser.Plugin.AStar.AStarNode[]; start: Phaser.Plugin.AStar.AStarNode; goal: Phaser.Plugin.AStar.AStarNode; visited: Phaser.Plugin.AStar.AStarNode[]; } } class ColorHarmony extends Phaser.Plugin { getAnalogousHarmony(color: number, threshold?: number): any; getComplementHarmony(color: number): number; getSplitComplementHarmony(color: number, threshold: number): any; getTriadicHarmony(color: number): any; } class CSS3Filters extends Phaser.Plugin { constructor(parent: PIXI.DisplayObject); blur: number; brightness: number; contrast: number; grayscale: number; hueRotate: number; invert: number; opacity: number; saturate: number; sepia: number; } class TilemapWalker extends Phaser.Plugin { constructor(game: Phaser.Game, map: Phaser.Tilemap, layer?: any, x?: number, y?: number); collides: boolean; game: Phaser.Game; history: boolean; facing: number; map: Phaser.Tilemap; location: Phaser.Point; locationLayer: number; checkTile(x: number, y: number): boolean; getTileFromLocation(x: number, y: number): Phaser.Tile; getTiles(width: number, height: number, center?: boolean): any[]; getTileBehind(distance?: number): Phaser.Tile; getTileBehindLeft(distance?: number): Phaser.Tile; getTileBehindRight(distance?: number): Phaser.Tile; getTileAhead(distance?: number): Phaser.Tile; getTileAheadLeft(distance?: number): Phaser.Tile; getTileAheadRight(distance?: number): Phaser.Tile; getTileLeft(distance: number): Phaser.Tile; getTileRight(distance: number): Phaser.Tile; moveForward(): boolean; moveBackward(): boolean; moveLeft(): boolean; moveRight(): boolean; putTile(index: number): void; setLocation(x: number, y: number, layer?: any): boolean; turnLeft(): void; turnRight(): void; updateLocation(x: number, y: number): boolean; } class SamplePlugin extends Phaser.Plugin { constructor(game: Phaser.Game, parent: PIXI.DisplayObject); addSprite(sprite: Phaser.Sprite): void; update(): void; } class VirtualJoystick extends Phaser.Plugin { constructor(game: Phaser.Game, parent: any); angle: number; base: Phaser.Sprite; baseBMD: Phaser.BitmapData; baseCircle: Phaser.Circle; deltaX: number; deltaY: number; distance: number; force: number; isDragging: boolean; limit: number; limitPoint: Phaser.Point; location: Phaser.Point; nub: Phaser.Sprite; nubBMD: Phaser.BitmapData; speed: number; x: number; y: number; init(x: number, y: number, diameter?: number, limit?: number): void; move(pointer: Phaser.Pointer, x: number, y: number): void; render(): void; setVelocity(sprite: Phaser.Sprite, minSpeed?: number, maxSpeed?: number): Phaser.Sprite; startDrag(): void; stopDrag(nub: Phaser.Sprite, pointer: Phaser.Pointer): void; update(): void; } class Webcam extends Phaser.Plugin { constructor(game: Phaser.Game, parent: PIXI.DisplayObject); active: boolean; context: any; stream: any; video: HTMLVideoElement; connectCallback: (stream: any) => void; errorCallback: (e: any) => void; grab: (context: any, x: number, y: number) => void; start(width: number, height: number, context: any): void; stop(): void; update(): void; } class Juicy extends Phaser.Plugin { constructor(game: Phaser.Game); createScreenFlash(color?: string): Phaser.Plugin.Juicy.ScreenFlash; createTrail(length?: number, color?: number): Phaser.Plugin.Juicy.Trail; overScale(object: Phaser.Sprite, scale?: number, initialScale?: Phaser.Point): void; jelly(object: Phaser.Sprite, strength?: number, delay?: number, initialScale?: Phaser.Point): void; mouseStretch(object: Phaser.Sprite, strength?: number, initialScale?: Phaser.Point): void; update(): void; shake(duration?: number, strength?: number): void; } module Juicy { class Trail { constructor(game: Phaser.Game, trailLength?: number, color?: number); target: Phaser.Sprite; trailLength: number; trailWidth: number; trailScaling: boolean; trailColor: number; update(): void; addSegment(x: number, y: number): void; redrawSegments(offsetX: number, offsetY: number): void; } class ScreenFlash { constructor(game: Phaser.Game, color?: string); flash(maxAlpha?: number, duration?: number): void; } } } interface PluginConstructorOf { new (...parameters: any[]): T; } class PluginManager implements IStateCycle { constructor(game: Phaser.Game); game: Phaser.Game; plugins: Phaser.Plugin[]; add(plugin: PluginConstructorOf, ...parameters: any[]): T; destroy(): void; postRender(): void; postUpdate(): void; preUpdate(): void; remove(plugin: Phaser.Plugin, destroy?: boolean): void; removeAll(): void; render(): void; update(): void; } class Point extends PIXI.Point { constructor(x?: number, y?: number); x: number; y: number; type: number; 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 angle(a: Phaser.Point, b: Phaser.Point): number; static angleSq(a: Phaser.Point, b: Phaser.Point): number; static negative(a: Phaser.Point, out?: Phaser.Point): Phaser.Point; static multiplyAdd(a: Phaser.Point, b: Phaser.Point, scale: number, out?: Phaser.Point): Phaser.Point; static interpolate(a: Phaser.Point, b: Phaser.Point, alpha: number, out?: Phaser.Point): Phaser.Point; static parse(obj: any, xProp?: string, yProp?: string): Phaser.Point; static perp(a: Phaser.Point, out?: Phaser.Point): Phaser.Point; static rperp(a: Phaser.Point, out?: Phaser.Point): Phaser.Point; static distance(a: any, b: any, round?: boolean): number; static project(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point; static projectUnit(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point; static normalRightHand(a: Phaser.Point, out?: Phaser.Point): Phaser.Point; static normalize(a: Phaser.Point, out?: Phaser.Point): Phaser.Point; static rotate(a: Phaser.Point, x: number, y: number, angle: number, asDegrees?: boolean, distance?: number): Phaser.Point; static centroid(points: Phaser.Point[], out?: Phaser.Point): Phaser.Point; add(x: number, y: number): Phaser.Point; angle(a: Phaser.Point, asDegrees?: boolean): number; angleSq(a: Phaser.Point): number; clamp(min: number, max: number): Phaser.Point; clampX(min: number, max: number): Phaser.Point; clampY(min: number, max: number): Phaser.Point; clone(output?: Phaser.Point): Phaser.Point; copyFrom(source: Phaser.Point): Phaser.Point; copyTo(dest: T): T; ceil(): Phaser.Point; cross(a: Phaser.Point): number; divide(x: number, y: number): Phaser.Point; distance(dest: Phaser.Point, round?: boolean): number; dot(a: Phaser.Point): number; equals(a: Phaser.Point): boolean; floor(): Phaser.Point; getMagnitude(): number; getMagnitudeSq(): number; invert(): Phaser.Point; isZero(): boolean; multiply(x: number, y: number): Phaser.Point; normalize(): Phaser.Point; normalRightHand(): Phaser.Point; perp(): Phaser.Point; rperp(): Phaser.Point; rotate(x: number, y: number, angle: number, asDegrees?: boolean, distance?: number): Phaser.Point; set(x: number, y?: number): Phaser.Point; setMagnitude(magnitude: number): Phaser.Point; setTo(x: number, y?: number): Phaser.Point; subtract(x: number, y: number): Phaser.Point; toString(): string; } class Pointer { constructor(game: Phaser.Game, id: number, pointerMode?: number); static NO_BUTTON: number; static LEFT_BUTTON: number; static RIGHT_BUTTON: number; static MIDDLE_BUTTON: number; static BACK_BUTTON: number; static FORWARD_BUTTON: number; static ERASER_BUTTON: number; active: boolean; backButton: Phaser.DeviceButton; button: any; circle: Phaser.Circle; clientX: number; clientY: number; dirty: boolean; duration: number; eraserButton: Phaser.DeviceButton; exists: boolean; forceOut: boolean; forwardButton: Phaser.DeviceButton; game: Phaser.Game; justReleasePreventsOver: boolean | number; id: number; identifier: number; interactiveCandidates: Phaser.InputHandler[]; isDown: boolean; isMouse: boolean; isUp: boolean; leftButton: Phaser.DeviceButton; middleButton: Phaser.DeviceButton; movementX: number; movementY: number; msSinceLastClick: number; pageX: number; pageY: number; pointerId: number; pointerMode: number; position: Phaser.Point; positionDown: Phaser.Point; positionUp: Phaser.Point; previousTapTime: number; rawMovementX: number; rawMovementY: number; rightButton: Phaser.DeviceButton; screenX: number; screenY: number; target: any; targetObject: any; timeDown: number; timeUp: number; totalTouches: number; type: number; withinGame: boolean; worldX: number; worldY: number; x: number; y: number; addClickTrampoline(name: string, callback: Function, callbackContext: any, ...callbackArgs: any[]): void; justPressed(duration?: number): boolean; justReleased(duration?: number): boolean; leave(event: any): void; move(event: any, fromClick?: boolean): void; reset(): void; resetButtons(): void; resetMovement(): void; start(event: any): void; stop(event: any): void; swapTarget(newTarget: Phaser.InputHandler, silent?: boolean): void; update(): void; updateButtons(event: MouseEvent): void; } class Polygon { constructor(points: Phaser.Point[] | number[]); constructor(...points: Phaser.Point[]); constructor(...points: number[]); area: number; flattened: boolean; points: number[] | Phaser.Point[]; type: number; clone(output: Phaser.Polygon): Phaser.Polygon; contains(x: number, y: number): boolean; flatten(): Phaser.Polygon; setTo(points: Phaser.Point[] | number[]): void; setTo(...points: Phaser.Point[]): void; setTo(...points: number[]): void; toNumberArray(output?: number[]): number[]; } class QuadTree { constructor(x: number, y: number, width: number, height: number, maxObject?: number, maxLevels?: number, level?: number); bounds: { x: number; y: number; width: number; height: number; subWidth: number; subHeight: number; right: number; bottom: number; }; level: number; maxObjects: number; maxLevels: number; objects: any[]; nodes: any[]; clear(): void; getIndex(rect: any): number; insert(body: any): void; populate(group: Phaser.Group): void; populateHandler(sprite: Phaser.Sprite): void; reset(x: number, y: number, width: number, height: number, maxObject?: number, maxLevels?: number, level?: number): void; retrieve(source: any): any[]; split(): void; } class RandomDataGenerator { constructor(seeds?: any[] | string); angle(): number; between(min: number, max: number): number; frac(): number; integer(): number; integerInRange(min: number, max: number): number; normal(): number; pick(ary: T[]): T; real(): number; realInRange(min: number, max: number): number; sign(): number; sow(seeds: any[]): void; state(state?: string): string; timestamp(min: number, max: number): number; uuid(): number; weightedPick(ary: T[]): T; } class Rectangle { constructor(x: number, y: number, width: number, height: number); bottom: number; bottomRight: Phaser.Point; bottomLeft: Phaser.Point; centerX: number; centerY: number; empty: boolean; halfHeight: number; halfWidth: number; height: number; left: number; perimeter: number; randomX: number; randomY: number; right: number; top: number; topLeft: Phaser.Point; topRight: Phaser.Point; type: number; volume: number; width: number; x: number; y: number; static aabb(points: Phaser.Point[], out?: Phaser.Rectangle): Phaser.Rectangle; 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 containsRaw(rx: number, ry: number, rw: number, rh: number, x: number, y: number): boolean; static containsRect(a: Phaser.Rectangle, b: Phaser.Rectangle): boolean; static equals(a: Phaser.Rectangle, b: Phaser.Rectangle): boolean; static inflate(a: Phaser.Rectangle, dx: number, dy: number): Phaser.Rectangle; static inflatePoint(a: Phaser.Rectangle, point: Phaser.Point): Phaser.Rectangle; static intersection(a: Phaser.Rectangle, b: Phaser.Rectangle, out?: Phaser.Rectangle): Phaser.Rectangle; static intersects(a: Phaser.Rectangle, b: Phaser.Rectangle): boolean; static intersectsRaw(left: number, right: number, top: number, bottom: number, tolerance: number): boolean; static size(a: Phaser.Rectangle, output?: Phaser.Point): Phaser.Point; static union(a: Phaser.Rectangle, b: Phaser.Rectangle, out?: Phaser.Rectangle): Phaser.Rectangle; ceil(): void; ceilAll(): void; centerOn(x: number, y: number): Phaser.Rectangle; clone(output: Phaser.Rectangle): Phaser.Rectangle; contains(x: number, y: number): boolean; containsRect(b: Phaser.Rectangle): boolean; copyFrom(source: any): Phaser.Rectangle; copyTo(dest: any): any; equals(b: Phaser.Rectangle): boolean; floor(): void; floorAll(): void; getPoint(position: number, out: Phaser.Point): Phaser.Point; inflate(dx: number, dy: number): Phaser.Rectangle; 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; offset(dx: number, dy: number): Phaser.Rectangle; offsetPoint(point: Phaser.Point): Phaser.Rectangle; random(out?: Phaser.Point): Phaser.Point; resize(width: number, height: number): Phaser.Rectangle; setTo(x: number, y: number, width: number, height: number): Phaser.Rectangle; scale(x: number, y?: number): Phaser.Rectangle; size(output?: Phaser.Point): Phaser.Point; toString(): string; union(b: Phaser.Rectangle, out?: Phaser.Rectangle): Phaser.Rectangle; } class RenderTexture extends PIXI.RenderTexture { constructor(game: Phaser.Game, width?: number, height?: number, key?: string, scaleMode?: number, resolution?: number); crop: PIXI.Rectangle; game: Phaser.Game; key: string; type: number; render(displayObject: PIXI.DisplayObject, matrix?: Phaser.Matrix, clear?: boolean): void; renderXY(displayObject: PIXI.DisplayObject, x: number, y: number, clear?: boolean): void; renderRawXY(displayObject: PIXI.DisplayObject, x: number, y: number, clear?: boolean): void; } class RequestAnimationFrame { constructor(game: Phaser.Game, forceSetTimeOut?: boolean); forceSetTimeOut: boolean; game: Phaser.Game; isRunning: boolean; isRAF(): boolean; isSetTimeOut(): boolean; start(): boolean; stop(): void; updateRAF(rafTime: number): void; updateSetTimeout(time: number): void; } class RetroFont extends Phaser.RenderTexture { constructor(game: Phaser.Game, key: string, characterWidth: number, characterHeight: number, chars: string, charsPerRow?: number, xSpacing?: number, ySpacing?: number, xOffset?: number, yOffset?: number); static ALIGN_CENTER: string; static ALIGN_LEFT: string; static ALIGN_RIGHT: string; static TEXT_SET1: string; static TEXT_SET2: string; static TEXT_SET3: string; static TEXT_SET4: string; static TEXT_SET5: string; static TEXT_SET6: string; static TEXT_SET7: string; static TEXT_SET8: string; static TEXT_SET9: string; static TEXT_SET10: string; static TEXT_SET11: string; align: string; autoUpperCase: boolean; characterHeight: number; characterPerRow: number; characterSpacingX: number; characterSpacingY: number; characterWidth: number; customSpacingX: number; customSpacingY: number; fixedWidth: number; fontSet: Image; frameData: Phaser.FrameData; multiLine: boolean; offsetX: number; offsetY: number; smoothed: boolean; stamp: Phaser.Image; text: string; buildRetroFontText(): void; getLongestLine(): number; pasteLine(line: string, x: number, y: number, customSpacingX: number): void; removeUnsupportedCharacters(stripCR?: boolean): string; setFixedWidth(width: number, lineAlignment?: string): void; setText(content: string, multiLine?: boolean, characterSpacing?: number, lineSpacing?: number, lineAlignment?: string, allowLowerCase?: boolean): void; updateOffset(x?: number, y?: number): void; } class Rope extends PIXI.Rope { constructor(game: Phaser.Game, x: number, y: number, key: string | Phaser.RenderTexture | Phaser.BitmapData | PIXI.Texture | Phaser.Video, frame?: string | number, points?: Phaser.Point[]); angle: number; animations: Phaser.AnimationManager; alive: boolean; autoCull: boolean; body: Phaser.Physics.Arcade.Body | Phaser.Physics.P2.Body | Phaser.Physics.Ninja.Body | any; bottom: number; cameraOffset: Phaser.Point; checkWorldBounds: boolean; cropRect: Phaser.Rectangle; components: any; customRender: boolean; debug: boolean; deltaX: number; deltaY: number; deltaZ: number; destroyPhase: boolean; exists: boolean; events: Phaser.Events; fixedToCamera: boolean; frame: string | number; frameName: string; fresh: boolean; game: Phaser.Game; inCamera: boolean; input: Phaser.InputHandler; inputEnabled: boolean; inWorld: boolean; left: number; lifespan: number; key: string | Phaser.RenderTexture | Phaser.BitmapData | PIXI.Texture | Phaser.Video; name: string; offsetX: number; offsetY: number; outOfBoundsKill: boolean; overlap(displayObject: Phaser.Sprite | Phaser.Image | Phaser.TileSprite | Phaser.Button | PIXI.DisplayObject): boolean; pendingDestroy: boolean; points: Phaser.Point[]; position: Phaser.Point; previousPosition: Phaser.Point; previousRotation: number; right: number; renderOrderID: number; segments: Phaser.Rectangle[]; smoothed: boolean; top: number; type: number; transformCallback: Function; transformCallbackContext: any; scaleMin: Phaser.Point; scaleMax: Phaser.Point; updateAnimation: Function; world: Phaser.Point; x: number; y: number; z: number; bringToTop(): Phaser.Rope; checkTransform(wt: PIXI.Matrix): void; crop(rect: Phaser.Rectangle, copy?: boolean): void; destroy(destroyChildren?: boolean): void; kill(): Phaser.Rope; loadTexture(key: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture, frame?: string | number, stopAnimation?: boolean): void; moveUp(): Phaser.Rope; moveDown(): Phaser.Rope; play(name: string, frameRate?: number, loop?: boolean, killOnComplete?: boolean): Phaser.Animation; preUpdate(): void; postUpdate(): void; reset(x: number, y: number, health?: number): Phaser.Rope; resizeFrame(parent: any, width: number, height: number): void; resetFrame(): void; revive(health?: number): Phaser.Rope; sendToBack(): Phaser.Rope; setFrame(frame: Phaser.Frame): void; setScaleMinMax(minX?: number, minY?: number, maxX?: number, maxY?: number): void; updateCrop(): void; update(): void; } class RoundedRectangle extends PIXI.RoundedRectangle { x: number; y: number; width: number; height: number; radius: number; type: number; clone(): RoundedRectangle; contains(x: number, y: number): boolean; } class Signal { active: boolean; boundDispatch: Function; memorize: boolean; add(listener: Function, listenerContext?: any, priority?: number, ...args: any[]): Phaser.SignalBinding; addOnce(listener: Function, listenerContext?: any, priority?: number, ...args: any[]): Phaser.SignalBinding; dispatch(...params: any[]): void; dispose(): void; forget(): void; getNumListeners(): number; halt(): void; has(listener: Function, context?: any): boolean; remove(listener: Function, context?: any): Function; removeAll(context?: any): void; toString(): string; validateListener(listener: Function, fnName: string): void; } class SignalBinding { constructor(signal: Phaser.Signal, listener: Function, isOnce: boolean, listenerContext?: any, priority?: number, ...args: any[]); active: boolean; callCount: number; context: any; params: any[]; execute(paramsArr?: any[]): void; detach(): Function; isBound(): boolean; isOnce(): boolean; getListener(): Function; getSignal(): Phaser.Signal; toString(): string; } class SinglePad { constructor(game: Phaser.Game, padParent: any); callbackContext: any; connected: boolean; deadZone: number; game: Phaser.Game; index: number; onAxisCallback: Function; onConnectCallback: Function; onDisconnectCallback: Function; onDownCallback: Function; onFloatCallback: Function; onUpCallback: Function; axis(axisCode: number): number; addCallbacks(context: any, callbacks: any): void; buttonValue(buttonCode: number): number; connect(rawPad: any): void; destroy(): void; disconnect(): void; getButton(buttonCode: number): Phaser.DeviceButton; isDown(buttonCode: number): boolean; isUp(buttonCode: number): boolean; justPressed(buttonCode: number, duration?: number): boolean; justReleased(buttonCode: number, duration?: number): boolean; pollStatus(): void; processAxisChange(axisState: any): void; processButtonDown(buttonCode: number, value: any): void; processButtonFloat(buttonCode: number, value: any): void; processButtonUp(buttonCode: number, value: any): void; reset(): void; } class Sound { constructor(game: Phaser.Game, key: string, volume?: number, loop?: boolean, connect?: boolean); autoplay: boolean; allowMultiple: boolean; context: any; currentMarker: string; currentTime: number; destroy(remove?: boolean): void; duration: number; durationMS: number; externalNode: any; fadeTween: Phaser.Tween; game: Phaser.Game; gainNode: any; isDecoded: boolean; isDecoding: boolean; isPlaying: boolean; key: string; loop: boolean; markers: any; masterGainNode: any; mute: boolean; name: string; onDecoded: Phaser.Signal; onEndedHandler: () => void; onFadeComplete: Phaser.Signal; onLoop: Phaser.Signal; onMarkerComplete: Phaser.Signal; onMute: Phaser.Signal; onPause: Phaser.Signal; onPlay: Phaser.Signal; onResume: Phaser.Signal; onStop: Phaser.Signal; override: boolean; paused: boolean; pausedPosition: number; pausedTime: number; pendingPlayback: boolean; position: number; startTime: number; stopTime: number; totalDuration: number; usingAudioTag: boolean; usingWebAudio: boolean; volume: number; addMarker(name: string, start: number, duration: number, volume?: number, loop?: boolean): void; destroy(): void; fadeIn(duration?: number, loop?: boolean, marker?: string): void; fadeOut(duration?: number): void; fadeTo(duration?: number, volume?: number): void; loopFull(volume?: number): Phaser.Sound; pause(): void; play(marker?: string, position?: number, volume?: number, loop?: boolean, forceRestart?: boolean): Phaser.Sound; removeMarker(name: string): void; restart(marker: string, position: number, volume?: number, loop?: boolean): void; resume(): void; soundHasUnlocked(key: string): void; stop(): void; update(): void; } class SoundManager { constructor(game: Phaser.Game); channels: number; connectToMaster: boolean; context: any; game: Phaser.Game; mute: boolean; muteOnPause: boolean; noAudio: boolean; onSoundDecode: Phaser.Signal; onVolumeChange: Phaser.Signal; onMute: Phaser.Signal; onUnMute: Phaser.Signal; touchLocked: boolean; usingAudioTag: boolean; usingWebAudio: boolean; volume: number; add(key: string, volume?: number, loop?: boolean, connect?: boolean): Phaser.Sound; addSprite(key: string): Phaser.AudioSprite; boot(): void; decode(key: string, sound?: Phaser.Sound): void; destroy(): void; pauseAll(): void; play(key: string, volume?: number, loop?: boolean): Phaser.Sound; remove(sound: Phaser.Sound): boolean; removeByKey(key: string): number; resumeAll(): void; setDecodedCallback(files: string[] | Phaser.Sound[], callback: Function, callbackContext: any): void; setTouchLock(): void; stopAll(): void; unlock(): boolean; update(): void; } class Sprite extends PIXI.Sprite { constructor(game: Phaser.Game, x: number, y: number, key?: string | Phaser.RenderTexture | Phaser.BitmapData | PIXI.Texture, frame?: string | number); alive: boolean; anchor: Phaser.Point; angle: number; animations: Phaser.AnimationManager; autoCull: boolean; body: Phaser.Physics.Arcade.Body | Phaser.Physics.P2.Body | Phaser.Physics.Ninja.Body | any; bottom: number; cameraOffset: Phaser.Point; centerX: number; centerY: number; checkWorldBounds: boolean; components: any; cropRect: Phaser.Rectangle; customRender: boolean; data: any; debug: boolean; deltaX: number; deltaY: number; deltaZ: number; destroyPhase: boolean; events: Phaser.Events; exists: boolean; fixedToCamera: boolean; frame: string | number; frameName: string; fresh: boolean; game: Phaser.Game; health: number; inCamera: boolean; input: Phaser.InputHandler; inputEnabled: boolean; inWorld: boolean; key: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture; left: number; lifespan: number; maxHealth: number; name: string; offsetX: number; offsetY: number; outOfBoundsKill: boolean; pendingDestroy: boolean; previousPosition: Phaser.Point; previousRotation: number; position: Phaser.Point; physicsEnabled: boolean; physicsType: number; renderOrderID: number; right: number; scale: Phaser.Point; scaleMin: Phaser.Point; scaleMax: Phaser.Point; smoothed: boolean; top: number; type: number; tintedTexture: HTMLCanvasElement; transformCallback: Function; transformCallbackContext: any; world: Phaser.Point; x: number; y: number; z: number; alignIn(container: Phaser.Rectangle | Phaser.Sprite | Phaser.Image | Phaser.Text | Phaser.BitmapText | Phaser.Button | Phaser.Graphics | Phaser.TileSprite, position?: number, offsetX?: number, offsetY?: number): any; alignTo(container: Phaser.Rectangle | Phaser.Sprite | Phaser.Image | Phaser.Text | Phaser.BitmapText | Phaser.Button | Phaser.Graphics | Phaser.TileSprite, position?: number, offsetX?: number, offsetY?: number): any; bringToTop(): Phaser.Sprite; crop(rect: Phaser.Rectangle, copy: boolean): void; checkTransform(wt: PIXI.Matrix): void; damage(amount: number): Phaser.Sprite; destroy(destroyChildren?: boolean): void; drawPolygon(): void; heal(amount: number): Phaser.Sprite; kill(): Phaser.Sprite; loadTexture(key: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture, frame?: string | number, stopAnimation?: boolean): void; moveUp(): Phaser.Sprite; moveDown(): Phaser.Sprite; overlap(displayObject: Phaser.Sprite | Phaser.Image | Phaser.TileSprite | Phaser.Button | PIXI.DisplayObject): boolean; play(name: string, frameRate?: number, loop?: boolean, killOnComplete?: boolean): Phaser.Animation; postUpdate(): void; preUpdate(): void; reset(x: number, y: number, health?: number): Phaser.Sprite; resetFrame(): void; resizeFrame(parent: any, width: number, height: number): void; revive(health?: number): Phaser.Sprite; sendToBack(): Phaser.Sprite; setFrame(frame: Phaser.Frame): void; setScaleMinMax(minX?: number, minY?: number, maxX?: number, maxY?: number): void; update(): void; updateCrop(): void; } class SpriteBatch extends Phaser.Group { constructor(game: Phaser.Game, parent: PIXI.DisplayObjectContainer, name?: string, addedToStage?: boolean); type: number; } class Stage extends PIXI.DisplayObjectContainer { constructor(game: Phaser.Game); game: Phaser.Game; name: string; disableVisibilityChange: boolean; exists: boolean; currentRenderOrderID: number; backgroundColor: any; smoothed: boolean; parseConfig(config: any): void; preUpdate(): void; update(): void; postUpdate(): void; updateTransform(): void; checkVisibility(): void; visibilityChange(event: Event): void; setBackgroundColor(backgroundColor: number | string): void; destroy(): void; } interface ResizeCallback { (scale: ScaleManager, parentBounds: Rectangle): any; } class ScaleManager { constructor(game: Phaser.Game, width: number | string, height: number | string); static EXACT_FIT: number; static NO_SCALE: number; static SHOW_ALL: number; static RESIZE: number; static USER_SCALE: number; aspectRatio: number; bounds: Rectangle; boundingParent: HTMLElement; compatibility: { canExpandParent: boolean; clickTrampoline: string; forceMinimumDocumentHeight: boolean; noMargins: boolean; scrollTo: Point; supportsFullScreen: boolean; }; currentScaleMode: number; dom: Phaser.DOM; enterIncorrectOrientation: Signal; event: any; forceLandscape: boolean; forcePortrait: boolean; fullScreenScaleMode: number; fullScreenTarget: HTMLElement; game: Phaser.Game; grid: Phaser.FlexGrid; hasPhaserSetFullScreen: boolean; height: number; incorrectOrientation: boolean; isFullScreen: boolean; isGameLandscape: boolean; isGamePortrait: boolean; isPortrait: boolean; isLandscape: boolean; leaveIncorrectOrientation: Signal; margin: { left: number; top: number; right: number; bottom: number; x: number; y: number; }; maxHeight: number; maxWidth: number; minHeight: number; minWidth: number; offset: Point; onFullScreenInit: Phaser.Signal; onFullScreenChange: Phaser.Signal; onFullScreenError: Phaser.Signal; onOrientationChange: Phaser.Signal; onSizeChange: Signal; pageAlignHorizontally: boolean; pageAlignVertically: boolean; parentNode: HTMLElement; parentIsWindow: boolean; parentScaleFactor: Point; scaleFactor: Point; scaleFactorInversed: Point; scaleMode: number; screenOrientation: string; sourceAspectRatio: number; trackParentInterval: number; width: number; windowConstraints: { bottom: string; right: string; }; boot(): void; createFullScreenTarget(): HTMLDivElement; destroy(): void; forceOrientation(forceLandscape: boolean, forcePortrait?: boolean): void; getParentBounds(target?: Rectangle): Rectangle; parseConfig(config: any): void; preUpdate(): void; pauseUpdate(): void; refresh(): void; setGameSize(width: number, height: number): void; setResizeCallback(callback: ResizeCallback, context: any): void; setUserScale(hScale: number, vScale: number, hTrim?: number, vTrim?: number): void; setMinMax(minWidth: number, minHeight: number, maxWidth?: number, maxHeight?: number): void; setupScale(width: number, height: number): void; setupScale(width: string, height: string): void; scaleSprite(sprite: Sprite, width?: number, height?: number, letterBox?: boolean): Sprite; scaleSprite(sprite: Image, width?: number, height?: number, letterBox?: boolean): Sprite; startFullScreen(antialias?: boolean, allowTrampoline?: boolean): boolean; stopFullScreen(): boolean; } class DOM { static visualBounds: Phaser.Rectangle; static layoutBounds: Phaser.Rectangle; static documentBounds: Phaser.Rectangle; static calibrate(coords: any, cushion?: number): any; static getAspectRatio(object: any): number; static getScreenOrientation(primaryFallback?: string): string; static getBounds(element: any, cushion?: number): any; static getOffset(element: any, point?: Point): Point; static inLayoutViewport(element: any, cushion?: number): boolean; } class State { add: Phaser.GameObjectFactory; cache: Phaser.Cache; camera: Phaser.Camera; game: Phaser.Game; input: Phaser.Input; key: string; load: Phaser.Loader; make: Phaser.GameObjectCreator; particles: Phaser.Particles; physics: Phaser.Physics; rnd: Phaser.RandomDataGenerator; scale: Phaser.ScaleManager; sound: Phaser.SoundManager; stage: Phaser.Stage; time: Phaser.Time; tweens: Phaser.TweenManager; world: Phaser.World; create(): void; init(...args: any[]): void; loadRender(): void; loadUpdate(): void; paused(): void; pauseUpdate(): void; preload(): void; preRender(): void; render(): void; resize(): void; resumed(): void; shutdown(): void; update(): void; } interface IStateCycle { preUpdate(): void; update(): void; render(): void; postRender(): void; destroy(): void; } class StateManager { constructor(game: Phaser.Game, pendingState?: Phaser.State); created: boolean; current: string; game: Phaser.Game; onCreateCallback: Function; onInitCallback: Function; onLoadRenderCallback: Function; onLoadUpdateCallback: Function; onPausedCallback: Function; onPauseUpdateCallback: Function; onPreloadCallback: Function; onPreRenderCallback: Function; onRenderCallback: Function; onResumedCallback: Function; onResizeCallback: Function; onShutDownCallback: Function; onUpdateCallback: Function; states: any; onStateChange: Phaser.Signal; add(key: string, state: any, autoStart?: boolean): void; checkState(key: string): boolean; clearCurrentState(): void; destroy(): void; getCurrentState(): Phaser.State; link(key: string): void; loadComplete(): void; preRender(elapsedTime: number): void; preUpdate(): void; render(): void; remove(key: string): void; resume(): void; restart(clearWorld?: boolean, clearCache?: boolean, ...args: any[]): void; resize(width: number, height: number): void; start(key: string, clearWorld?: boolean, clearCache?: boolean, ...args: any[]): void; update(): void; unlink(key: string): void; } interface PhaserTextStyle { font?: string; fill?: any; align?: string; stroke?: string; strokeThickness?: number; wordWrap?: boolean; wordWrapWidth?: number; maxLines?: number; shadowOffsetX?: number; shadowOffsetY?: number; shadowColor?: string; shadowBlur?: number; valign?: string; tab?: number; tabs?: number; fontSize?: number; fontStyle?: string; fontVariant?: string; fontWeight?: string | number; backgroundColor?: string; boundsAlignH?: string; boundsAlignV?: string; } class Text extends Phaser.Sprite { constructor(game: Phaser.Game, x: number, y: number, text: string, style?: PhaserTextStyle); static fontPropertiesCanvas: any; static fontPropertiesContext: any; static fontPropertiesCache: any; align: string; angle: number; autoRound: boolean; boundsAlignH: string; boundsAlignV: string; cameraOffset: Phaser.Point; canvas: HTMLCanvasElement; colors: string[]; context: CanvasRenderingContext2D; cssFont: string; destroyPhase: boolean; events: Phaser.Events; exists: boolean; fill: any; fixedToCamera: boolean; font: string; fontSize: number | string; fontStyle: string; fontStyles: string[]; fontVariant: string; fontWeight: string | number; fontWeights: (string | number)[]; game: Phaser.Game; input: Phaser.InputHandler; inputEnabled: boolean; lineSpacing: number; name: string; padding: Phaser.Point; pendingDestroy: boolean; physicsType: number; position: Phaser.Point; previousPosition: Phaser.Point; previousRotation: number; renderOrderID: number; resolution: number; shadowBlur: number; shadowColor: string; shadowFill: boolean; shadowOffsetX: number; shadowOffsetY: number; shadowStroke: boolean; stroke: string; strokeColors: string[]; strokeThickness: number; scale: Phaser.Point; tab: number; tabs: number | number[]; text: string; textBounds: Phaser.Rectangle; type: number; useAdvancedWrap: boolean; world: Phaser.Point; wordWrap: boolean; wordWrapWidth: number; z: number; addColor(color: string, position: number): Phaser.Text; addFontStyle(style: string, position: number): Phaser.Text; addFontWeight(weight: string, position: number): Phaser.Text; addStrokeColor(color: string, position: number): Phaser.Text; alignIn(container: Phaser.Rectangle | Phaser.Sprite | Phaser.Image | Phaser.Text | Phaser.BitmapText | Phaser.Button | Phaser.Graphics | Phaser.TileSprite, position?: number, offsetX?: number, offsetY?: number): any; alignTo(container: Phaser.Rectangle | Phaser.Sprite | Phaser.Image | Phaser.Text | Phaser.BitmapText | Phaser.Button | Phaser.Graphics | Phaser.TileSprite, position?: number, offsetX?: number, offsetY?: number): any; clearColors(): Phaser.Text; clearFontValues(): Phaser.Text; componentsToFont(components: any): string; destroy(destroyChildren?: boolean): void; fontToComponents(font: string): any; postUpdate(): void; parseList(list: any[]): Phaser.Text; precalculateWordWrap(text: string): string[]; preUpdate(): void; renderTabLine(line: string, x: number, y: number, fill?: boolean): void; setShadow(x?: number, y?: number, color?: any, blur?: number, shadowStroke?: boolean, shadowFill?: boolean): Phaser.Text; setStyle(style?: PhaserTextStyle, update?: boolean): Phaser.Text; setText(text: string, immediate?: boolean): Phaser.Text; setTextBounds(x?: number, y?: number, width?: number, height?: number): Phaser.Text; update(): void; updateFont(components: any): void; updateLine(text: string, x?: number, y?: number): void; updateShadow(state?: boolean): void; updateTexture(): void; } class Tile { constructor(layer: any, index: number, x: number, y: Number, width: number, height: number); alpha: number; bottom: number; callback: Function; callbackContext: any; centerX: number; centerY: number; canCollide: boolean; collideDown: boolean; collideLeft: boolean; collideNone: boolean; collideRight: boolean; collisionCallback: Function; collisionCallbackContext: any; collides: boolean; collideUp: boolean; faceBottom: boolean; faceLeft: boolean; faceRight: boolean; faceTop: boolean; game: Phaser.Game; height: number; index: number; layer: any; left: number; properties: any; right: number; scanned: boolean; top: number; width: number; worldX: number; worldY: number; x: number; y: number; copy(tile: Phaser.Tile): Phaser.Tile; containsPoint(x: number, y: number): boolean; destroy(): void; intersects(x: number, y: number, right: number, bottom: number): boolean; isInterested(collides: boolean, faces: boolean): boolean; resetCollision(): void; setCollision(left: boolean, right: boolean, up: boolean, down: boolean): void; setCollisionCallback(callback: Function, context: any): void; } class Tilemap { constructor(game: Phaser.Game, key?: string, tileWidth?: number, tileHeight?: number, width?: number, height?: number); static CSV: number; static TILED_JSON: number; static NORTH: number; static EAST: number; static SOUTH: number; static WEST: number; collision: any[]; collideIndexes: any[]; currentLayer: number; debugMap: any[]; enableDebug: boolean; format: number; game: Phaser.Game; height: number; heightInPixels: number; images: any[]; imagecollections: ImageCollection[]; key: string; layer: Phaser.TilemapLayer[]; layers: any[]; objects: any[]; orientation: string; properties: any; rayStepRate: number; tileHeight: number; tiles: Phaser.Tile[]; tilesets: Phaser.Tileset[]; tileWidth: number; version: number; width: number; widthInPixels: number; addTilesetImage(tileset: string, key?: string | Phaser.BitmapData, tileWidth?: number, tileHeight?: number, tileMargin?: number, tileSpacing?: number, gid?: number): Phaser.Tileset; calculateFaces(layer: number): void; copy(x: number, y: number, width: number, height: number, layer?: any): Phaser.Tile[]; create(name: string, width: number, height: number, tileWidth: number, tileHeight: number, group?: Phaser.Group): Phaser.TilemapLayer; createBlankLayer(name: string, width: number, height: number, tileWidth: number, tileHeight: number, group?: Phaser.Group): Phaser.TilemapLayer; createFromObjects(name: string, gid: number, key: string, frame?: any, exists?: boolean, autoCull?: boolean, group?: Phaser.Group, CustomClass?: any, adjustY?: boolean): void; createFromTiles(tiles: any, replacements: any, key: string, layer?: any, group?: Phaser.Group, properties?: any): number; createLayer(layer: any, width?: number, height?: number, group?: Phaser.Group): Phaser.TilemapLayer; destroy(): void; dump(): void; fill(index: number, x: number, y: number, width: number, height: number, layer?: any): void; forEach(callback: Function, context: any, x: number, y: Number, width: number, height: number, layer?: any): void; getImageIndex(name: string): number; getIndex(location: any[], name: string): number; getLayer(layer: any): number; getLayerIndex(name: string): number; getObjectIndex(name: string): number; getTile(x: number, y: number, layer?: any, nonNull?: boolean): Phaser.Tile; getRayCastTiles(layer: Phaser.TilemapLayer|Phaser.TilemapLayerGL, line: Phaser.Line, stepRate?: number, collides?: boolean, interestingFace?: boolean): Phaser.Tile[]; getTiles(layer: Phaser.TilemapLayer|Phaser.TilemapLayerGL, x: number, y: number, width: number, height: number, collides?: boolean, interestingFace?: boolean): Phaser.Tile[]; getTileX(layer: Phaser.TilemapLayer|Phaser.TilemapLayerGL, x: number): number; getTileXY(layer: Phaser.TilemapLayer|Phaser.TilemapLayerGL, x: number, y: number, point: Phaser.Point): Phaser.Point; getTileY(layer: Phaser.TilemapLayer|Phaser.TilemapLayerGL, y: number): number; getTileAbove(layer: number, x: number, y: number): Phaser.Tile; getTileBelow(layer: number, x: number, y: number): Phaser.Tile; getTileLeft(layer: number, x: number, y: number): Phaser.Tile; getTileRight(layer: number, x: number, y: number): Phaser.Tile; getTilesetIndex(name: string): number; getTileWorldXY(x: number, y: number, tileWidth?: number, tileHeight?: number, layer?: number | string | Phaser.TilemapLayer, nonNull?: boolean): Phaser.Tile; hasTile(x: number, y: number, layer: Phaser.TilemapLayer): boolean; paste(x: number, y: number, tileblock: Phaser.Tile[], layer?: any): void; putTile(tile: any, x: number, y: number, layer?: any): Phaser.Tile; putTileWorldXY(tile: any, x: number, y: number, tileWidth: number, tileHeight: number, layer?: any): void; random(x: number, y: number, width: number, height: number, layer?: any): void; removeAllLayers(): void; removeTile(x: number, y: number, layer?: any): Phaser.Tile; removeTileWorldXY(x: number, y: number, tileWidth: number, tileHeight: number, layer?: any): Phaser.Tile; replace(source: number, dest: number, x: number, y: number, width: number, height: number, layer?: any): void; searchTileIndex(index: number, skip?: number, reverse?: boolean, layer?: any): Phaser.Tile; setCollision(indexes: any, collides?: boolean, layer?: any, recalculate?: boolean): void; setCollisionBetween(start: number, stop: number, collides?: boolean, layer?: any, recalculate?: boolean): void; setCollisionByExclusion(indexes: any[], collides?: boolean, layer?: any, recalculate?: boolean): void; setCollisionByIndex(index: number, collides?: boolean, layer?: number, recalculate?: boolean): void; setLayer(layer: any): void; setPreventRecalculate(value: boolean): void; setTileIndexCallback(indexes: any, callback: Function, callbackContext: any, layer?: any): void; setTileLocationCallback(x: number, y: number, width: number, height: number, callback: Function, callbackContext: any, layer?: any): void; setTileSize(tileWidth: number, tileHeight: number): void; shuffle(x: number, y: number, width: number, height: number, layer: any): void; swap(tileA: number, tileB: number, x: number, y: number, width: number, height: number, layer?: any): void; } class TilemapLayer extends Phaser.Sprite { constructor(game: Phaser.Game, tilemap: Phaser.Tilemap, index: number, width?: number, height?: number); cameraOffset: Phaser.Point; canvas: HTMLCanvasElement; collisionHeight: number; collisionWidth: number; context: CanvasRenderingContext2D; data: any; debug: boolean; debugAlpha: number; debugCallbackColor: string; debugColor: string; debugSettings: { missingImageFill: string; debuggedTileOverfill: string; forceFullRedraw: boolean; debugAlpha: number; facingEdgeStroke: string; collidingTileOverfill: string; }; dirty: boolean; exists: boolean; fixedToCamera: boolean; game: Phaser.Game; index: number; layer: Phaser.TilemapLayer; map: Phaser.Tilemap; name: string; physicsType: number; renderSettings: { enableScrollDelta: boolean; overdrawRatio: number; copyCanvas: any; }; scrollFactorX: number; scrollFactorY: number; scrollX: number; scrollY: number; type: number; wrap: boolean; destroy(): void; postUpdate(): void; render(): void; resize(width: number, height: number): void; resizeWorld(): void; resetTilesetCache(): void; setScale(xScale?: number, yScale?: number): void; updateMax(): void; } class TilemapLayerGL { constructor(game: Phaser.Game, tilemap: Phaser.Tilemap, index: number, width?: number, height?: number, tileset?: Phaser.Tileset); collisionHeight: number; collisionWidth: number; data: any; dirty: boolean; exists: boolean; fixedToCamera: boolean; game: Phaser.Game; index: number; layer: Phaser.TilemapLayer; map: Phaser.Tilemap; name: string; physicsType: number; scrollFactorX: number; scrollFactorY: number; scrollX: number; scrollY: number; type: number; wrap: boolean; x: number; y: number; width: number; height: number; destroy(): void; postUpdate(): void; render(): void; resize(width: number, height: number): void; resizeWorld(): void; resetTilesetCache(): void; setScale(xScale?: number, yScale?: number): void; updateMax(): void; } class TilemapParser { static INSERT_NULL: boolean; static getEmptyData(tileWidth?: number, tileHeight?: number, width?: number, height?: number): any; static parse(game: Phaser.Game, key: string, tileWidth?: number, tileHeight?: number, width?: number, height?: number): any; static parseCSV(key: string, data: string, tileWidth?: number, tileHeight?: number): any; static parseJSON(json: any): any; } class Tileset { constructor(name: string, firstgid: number, width?: number, height?: number, margin?: number, spacing?: number, properties?: any); columns: number; firstgid: number; image: any; lastgid: number; name: string; properties: any; rows: number; tileHeight: number; tileMargin: number; tileSpacing: number; tileWidth: number; total: number; containsTileIndex(tileIndex: number): boolean; draw(context: CanvasRenderingContext2D, x: number, y: number, index: number): void; drawGl(glBatch: any[], x: number, y: number, index: number, alpha: number, flippedVal: number): void; setImage(image: any): void; setSpacing(margin?: number, spacing?: number): void; } class TileSprite extends PIXI.TilingSprite { constructor(game: Phaser.Game, x: number, y: number, width: number, height: number, key?: string | Phaser.RenderTexture | Phaser.BitmapData | PIXI.Texture, frame?: string | number); alive: boolean; angle: number; animations: Phaser.AnimationManager; autoCull: boolean; body: Phaser.Physics.Arcade.Body | Phaser.Physics.P2.Body | Phaser.Physics.Ninja.Body | any; bottom: number; cameraOffset: Phaser.Point; checkWorldBounds: boolean; components: any; customRender: boolean; data: any; debug: boolean; destroyPhase: boolean; events: Phaser.Events; exists: boolean; fixedToCamera: boolean; frame: string | number; frameName: string; fresh: boolean; game: Phaser.Game; inCamera: boolean; input: Phaser.InputHandler; inputEnabled: boolean; inWorld: boolean; key: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture; left: number; name: string; offsetX: number; offsetY: number; outOfBoundsKill: boolean; pendingDestroy: boolean; physicsType: number; position: Phaser.Point; smoothed: boolean; previousPosition: Phaser.Point; previousRoation: number; right: number; top: number; renderOrderID: number; type: number; world: Phaser.Point; z: number; alignIn(container: Phaser.Rectangle | Phaser.Sprite | Phaser.Image | Phaser.Text | Phaser.BitmapText | Phaser.Button | Phaser.Graphics | Phaser.TileSprite, position?: number, offsetX?: number, offsetY?: number): any; alignTo(container: Phaser.Rectangle | Phaser.Sprite | Phaser.Image | Phaser.Text | Phaser.BitmapText | Phaser.Button | Phaser.Graphics | Phaser.TileSprite, position?: number, offsetX?: number, offsetY?: number): any; autoScroll(x: number, y: number): void; destroy(destroyChildren?: boolean): void; loadTexture(key: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture, frame?: string | number, stopAnimation?: boolean): void; play(name: string, frameRate?: number, loop?: boolean, killOnComplete?: boolean): Phaser.Animation; postUpdate(): void; preUpdate(): void; overlap(displayObject: Phaser.Sprite | Phaser.Image | Phaser.TileSprite | Phaser.Button | PIXI.DisplayObject): boolean; reset(x: number, y: number, health?: number): Phaser.TileSprite; resizeFrame(parent: any, width: number, height: number): void; resetFrame(): void; setFrame(frame: Phaser.Frame): void; stopScroll(): void; update(): void; } class Time { constructor(game: Phaser.Game); advancedTiming: boolean; desiredFps: number; desiredFpsMult: number; elapsed: number; events: Phaser.Timer; elapsedMS: number; fps: number; fpsMax: number; fpsMin: number; frames: number; game: Phaser.Game; lastTime: number; msMax: number; msMin: number; now: number; pausedTime: number; pauseDuration: number; physicsElapsed: number; physicsElapsedMS: number; prevTime: number; slowMotion: number; suggestedFps: number; time: number; timeExpected: number; timeToCall: number; add(timer: Phaser.Timer): Phaser.Timer; boot(): void; create(autoDestroy?: boolean): Phaser.Timer; elapsedSecondsSince(since: number): number; elapsedSince(since: number): number; removeAll(): void; reset(): void; totalElapsedSeconds(): number; update(time: number): void; } class Timer { constructor(game: Phaser.Game, autoDestroy?: boolean); static HALF: number; static MINUTE: number; static QUARTER: number; static SECOND: number; autoDestroy: boolean; duration: number; events: Phaser.TimerEvent[]; expired: boolean; game: Phaser.Game; length: number; ms: number; next: number; nextTick: number; onComplete: Phaser.Signal; running: boolean; paused: boolean; seconds: number; add(delay: number, callback: Function, callbackContext?: any, ...args: any[]): Phaser.TimerEvent; clearPendingEvents(): void; destroy(): void; loop(delay: number, callback: Function, callbackContext?: any, ...args: any[]): Phaser.TimerEvent; order(): void; pause(): void; remove(event: Phaser.TimerEvent): boolean; removeAll(): void; repeat(delay: number, repeatCount: number, callback: Function, callbackContext?: any, ...args: any[]): Phaser.TimerEvent; resume(): void; sortHandler(a: any, b: any): number; start(startDelay?: number): void; stop(clearEvents?: boolean): void; update(time: number): boolean; } class TimerEvent { constructor(timer: Phaser.Timer, delay: number, tick: number, repeatCount: number, loop: boolean, callback: Function, callbackContext: any, ...args: any[]); args: any[]; callback: Function; callbackContext: any; delay: number; loop: boolean; pendingDelete: boolean; repeatCount: number; tick: number; timer: Phaser.Timer; } class Touch { constructor(game: Phaser.Game); callbackContext: any; enabled: boolean; event: any; game: Phaser.Game; preventDefault: boolean; touchCancelCallback: Function; touchEndCallback: Function; touchEnterCallback: Function; touchLeaveCallback: Function; touchMoveCallback: Function; touchStartCallback: Function; touchLockCallbacks: Function[]; addTouchLockCallback(callback: Function, context?: any, onEnd?: Function): void; removeTouchLockCallback(callback: Function, context?: any): boolean; consumeTouchMove(): void; onTouchCancel(event: any): void; onTouchEnd(event: any): void; onTouchEnter(event: any): void; onTouchLeave(event: any): void; onTouchMove(event: any): void; onTouchStart(event: any): void; start(): void; stop(): void; } class Tween { constructor(target: any, game: Phaser.Game, manager: Phaser.TweenManager); chainedTween: Phaser.Tween; current: number; frameBased: boolean; game: Phaser.Game; isRunning: boolean; isPaused: boolean; manager: Phaser.TweenManager; onChildComplete: Phaser.Signal; onComplete: Phaser.Signal; onLoop: Phaser.Signal; onRepeat: Phaser.Signal; onStart: Phaser.Signal; pendingDelete: boolean; properties: any; repeatCounter: number; reverse: boolean; target: any; timeline: Phaser.TweenData[]; timeScale: number; totalDuration: number; chain(...args: any[]): Phaser.Tween; delay(duration: number, index?: number): Phaser.Tween; easing(ease: Function, index?: number): Phaser.Tween; easing(ease: string, index?: number): Phaser.Tween; from(properties: any, duration?: number, ease?: Function, autoStart?: boolean, delay?: number, repeat?: number, yoyo?: boolean): Phaser.Tween; from(properties: any, duration?: number, ease?: string, autoStart?: boolean, delay?: number, repeat?: number, yoyo?: boolean): Phaser.Tween; generateData(frameRate?: number, data?: any): any[]; interpolation(interpolation: Function, context?: any, index?: number): Phaser.Tween; loop(value?: boolean): Phaser.Tween; onUpdateCallback(callback: Function, callbackContext?: any): Phaser.Tween; pause(): void; repeat(total: number, repeatDelay?: number, index?: number): Phaser.Tween; repeatDelay(duration: number, index?: number): Phaser.Tween; repeatAll(total?: number): Phaser.Tween; resume(): void; start(index?: number): Phaser.Tween; stop(complete?: boolean): Phaser.Tween; to(properties: any, duration?: number, ease?: Function, autoStart?: boolean, delay?: number, repeat?: number, yoyo?: boolean): Phaser.Tween; to(properties: any, duration?: number, ease?: string, autoStart?: boolean, delay?: number, repeat?: number, yoyo?: boolean): Phaser.Tween; update(time: number): boolean; updateTweenData(property: string, value: number | Function, index?: number): Phaser.Tween; yoyo(enable: boolean, yoyoDelay?: number, index?: number): Phaser.Tween; yoyoDelay(duration: number, index?: number): Phaser.Tween; } class TweenData { constructor(parent: Phaser.Tween); static COMPLETE: number; static LOOPED: number; static PENDING: number; static RUNNING: number; delay: number; dt: number; duration: number; easingFunction: Function; game: Phaser.Game; inReverse: boolean; interpolate: boolean; interpolateFunctionContext: Phaser.Math; interpolationContext: Phaser.Math; interpolationFunction: Function; isRunning: boolean; isFrom: boolean; parent: Phaser.Tween; percent: number; repeatCounter: number; startTime: number; value: number; yoyo: boolean; yoyoDelay: number; from(properties: any, duration?: number, ease?: Function, delay?: number, repeat?: number, yoyo?: boolean): Phaser.TweenData; generateData(frameRate?: number): any[]; repeat(): number; start(): Phaser.TweenData; to(properties: any, duration?: number, ease?: Function, delay?: number, repeat?: number, yoyo?: boolean): Phaser.TweenData; update(time: number): number; } class TweenManager { constructor(game: Phaser.Game); frameBased: boolean; game: Phaser.Game; add(tween: Phaser.Tween): Phaser.Tween; create(object: any): Phaser.Tween; getAll(): Phaser.Tween[]; isTweening(object: any): boolean; remove(tween: Phaser.Tween): Phaser.Tween; removeAll(): void; removeFrom(obj: any, children?: boolean): void; resumeAll(): void; update(): boolean; pauseAll(): void; } class Utils { static getProperty(obj: any, prop: string): any; static setProperty(obj: any, prop: string, value: any): any; static chanceRoll(chance: number): boolean; static randomChoice(choice1: string | number, choice2: any): any; static reverseString(string: string): string; static parseDimension(size: any, dimension: number): number; static pad(str: string, len?: number, pad?: string, dir?: number): string; static isPlainObject(object: any): boolean; static extend(deep: boolean, target: any, ...args: any[]): any; static mixinPrototype(target: any, mixin: any, replace?: boolean): void; static mixin(from: T, to: any): T; } module Utils { class Debug { constructor(game: Phaser.Game); bmd: Phaser.BitmapData; canvas: HTMLCanvasElement; columnWidth: number; context: CanvasRenderingContext2D; currentAlpha: number; currentX: number; currentY: number; dirty: boolean; font: string; game: Phaser.Game; lineHeight: number; renderShadow: boolean; sprite: Phaser.Image; AStar(astar: Phaser.Plugin.AStar, x: number, y: number, showVisited: boolean): void; boot(): void; body(sprite: Phaser.Sprite, color?: string, filled?: boolean): void; bodyInfo(sprite: Phaser.Sprite, x: number, y: Number, color?: string): void; box2dBody(body: Phaser.Sprite, color?: string): void; box2dWorld(): void; cameraInfo(camera: Phaser.Camera, x: number, y: number, color?: string): void; destroy(): void; geom(object: any, color?: string, fiiled?: boolean, forceType?: number): void; inputInfo(x: number, y: number, color?: string): void; lineInfo(line: Phaser.Line, x: number, y: number, color?: string): void; key(key: Phaser.Key, x?: number, y?: number, color?: string): void; line(...args: string[]): void; preUpdate(): void; pixel(x: number, y: number, color?: string, size?: number): void; pointer(pointer: Phaser.Pointer, hideIfUp?: boolean, downColor?: string, upColor?: string, color?: string): void; quadTree(quadtree: Phaser.QuadTree, color?: string): void; rectangle(object: Phaser.Rectangle, color?: string, filled?: boolean): void; reset(): void; ropeSegments(rope: Phaser.Rope, color?: number, filled?: boolean): void; soundInfo(sound: Phaser.Sound, x: number, y: number, color?: string): void; spriteBounds(sprite: any, color?: string, filled?: boolean): void; spriteCoords(sprite: any, x: number, y: number, color?: string): void; spriteInfo(sprite: Phaser.Sprite, x: number, y: number, color?: string): void; spriteInputInfo(sprite: Phaser.Sprite, x: number, y: number, color?: string): void; start(x?: number, y?: number, color?: string, columnWidth?: number): void; stop(): void; text(text: string, x: number, y: number, color?: string, font?: string): void; timer(timer: Phaser.Timer, x: number, y: number, color?: string): void; } } class Weapon extends Phaser.Plugin { constructor(game: Phaser.Game, parent: Phaser.PluginManager); static KILL_NEVER: number; static KILL_LIFESPAN: number; static KILL_DISTANCE: number; static KILL_WEAPON_BOUNDS: number; static KILL_CAMERA_BOUNDS: number; static KILL_WORLD_BOUNDS: number; static KILL_STATIC_BOUNDS: number; autoExpandBulletsGroup: boolean; autofire: boolean; bounds: Phaser.Rectangle; bulletAngleOffset: number; bulletAngleVariance: number; bulletAnimation: string; bulletClass: any; bulletCollideWorldBounds: boolean; bulletFrame: string; bulletFrameCycle: boolean; bulletFrameRandom: boolean; bulletFrames: any[]; bulletGravity: Phaser.Point; bulletInheritSpriteSpeed: boolean; bulletKey: string; bulletKillDistance: number; bulletKillType: number; bulletLifespan: number; bulletRotateToVelocity: boolean; bullets: Phaser.Group; bulletSpeed: number; bulletSpeedVariance: number; bulletWorldWrap: boolean; bulletWorldWrapPadding: number; fireAngle: number; fireFrom: Phaser.Rectangle; fireLimit: number; fireRate: number; fireRateVariance: number; onFire: Phaser.Signal; onFireLimit: Phaser.Signal; onKill: Phaser.Signal; shots: number; trackedPointer: Phaser.Pointer; trackedSprite: any; trackOffset: Phaser.Point; trackRotation: boolean; x: number; y: number; addBulletAnimation(name: string, frames?: number[] | string[], frameRate?: number, loop?: boolean, useNumericIndex?: boolean): Phaser.Weapon; createBullets(quantity?: number, key?: any, frame?: any, group?: Phaser.Group): Phaser.Weapon; debug(x?: number, y?: number, debugBodies?: boolean): void; destroy(): void; fire(from?: any, x?: number, y?: number): Phaser.Bullet; fireAtPointer(pointer: Phaser.Pointer): Phaser.Bullet; fireAtSprite(sprite: Phaser.Sprite): Phaser.Bullet; fireAtXY(x: number, y: number): Phaser.Bullet; forEach(callback: any, callbackContext: any): Phaser.Weapon; killAll(): Phaser.Weapon; pauseAll(): Phaser.Weapon; resetShots(newLimit?: number): Phaser.Weapon; resumeAll(): Phaser.Weapon; setBulletBodyOffset(width: number, height: number, offsetX?: number, offsetY?: number): Phaser.Weapon; setBulletFrames(min: number, max: number, cycle?: boolean, random?: boolean): Phaser.Weapon; trackPointer(pointer: Phaser.Pointer, offsetX?: number, offsetY?: number): Phaser.Weapon; trackSprite(sprite: Phaser.Sprite, offsetX?: number, offsetY?: number, trackRotation?: boolean): Phaser.Weapon; } class World extends Phaser.Group { constructor(game: Phaser.Game); bounds: Phaser.Rectangle; camera: Phaser.Camera; centerX: number; centerY: number; game: Phaser.Game; height: number; isPaused: boolean; randomX: number; randomY: number; stats: { skipped: number; ignored: number; checked: number; }; width: number; boot(): void; getObjectsUnderPointer(pointer: Phaser.Pointer, group: Phaser.Group, callback?: Function, callbackContext?: any): Phaser.Sprite; resize(width: number, height: number): void; setBounds(x: number, y: number, width: number, height: number): void; sortLeftRight(a: Phaser.Sprite, b: Phaser.Sprite): number; sortRightLeft(a: Phaser.Sprite, b: Phaser.Sprite): number; sortTopBottom(a: Phaser.Sprite, b: Phaser.Sprite): number; sortBottomTop(a: Phaser.Sprite, b: Phaser.Sprite): number; sort(group: Phaser.Group, sortDirection?: number): void; sort(key?: string, order?: number): void; shutdown(): void; wrap(sprite: any, padding?: number, useBounds?: boolean, horizontal?: boolean, vertical?: boolean): void; } }