diff --git a/dist/phaser.plugin.isometric.d.ts b/dist/phaser.plugin.isometric.d.ts
index a67c9d0..ca7d47f 100644
--- a/dist/phaser.plugin.isometric.d.ts
+++ b/dist/phaser.plugin.isometric.d.ts
@@ -1,49 +1,327 @@
+//debug octreee is missing - Octree 
+//debug isoSprite is missing - IsoSprite
+//gameobjectcreator isoSprite missing - IsoSprite
+//gameobjectfactory isoSprite missing - IsoSprite
+//debug body missing - Body
+//debug bodyInfo missing -Body
 declare module Phaser.Plugin {
-	class Isometric extends Phaser.Plugin {
-		projector: Phaser.Plugin.Isometric.Projector;
 
-		constructor(game: Phaser.Game, parent?: any);
+    class Isometric extends Phaser.Plugin {
 
-		addIsoSprite(x: number, y: number, z: number, key?: any, frame?: any, group?: Phaser.Group): Phaser.Sprite;
-	}
+        static CLASSIC: number;
+        static ISOMETRIC: number;
+        static MILITARY: number;
 
-	module Isometric {
-		class Projector {
-			game: Phaser.Game;
-			anchor: Phaser.Point;
-			projectionAngle: number;
+        static VERSION: string;
+        static UP: number;
+        static DOWN: number;
+        static FORWARDX: number;
+        static FORWARDY: number;
+        static BACKWARDX: number;
+        static BACKWARDY: number;
 
-			project(point3:Phaser.Plugin.Isometric.Point3, out:Phaser.Point) : Phaser.Point;
-			projectXy(point3:Phaser.Plugin.Isometric.Point3, out:Phaser.Point) : Phaser.Point;
-			unproject(point:Phaser.Point, out: Phaser.Plugin.Isometric.Point3, z: number): Phaser.Plugin.Isometric.Point3;
-			simpleSort(group: Phaser.Group);
-			topologicalSort(group: Phaser.Group, padding: number, prop: string);
+        static ISOSPRITE: number;
+        static ISOARCADE: number;
 
-		}
+        projector: Phaser.Plugin.Isometric.Projector;
 
-		class Point3 {
-			x: number;
-			y: number;
-			z: number;
+        constructor(game: Phaser.Game, parent?: any);
 
-			constructor(x: number, y: number, z: number);
-			
-			copyFrom(source:Phaser.Plugin.Isometric.Point3) : Phaser.Plugin.Isometric.Point3;
-			copyto(dest:Phaser.Plugin.Isometric.Point3) : Phaser.Plugin.Isometric.Point3;
-			equals(a:Phaser.Plugin.Isometric.Point3) : boolean;
-			set(x: number, y: number, z: number) : Phaser.Plugin.Isometric.Point3;
-			setTo(x: number, y: number, z: number) : Phaser.Plugin.Isometric.Point3;
-			add(x: number, y: number) : Phaser.Plugin.Isometric.Point3;
-			subtract(x: number, y: number, z: number) : Phaser.Plugin.Isometric.Point3;
-			multiply(x: number, y: number, z: number) : Phaser.Plugin.Isometric.Point3;
-			divide(x: number, y: number, z: number) : Phaser.Plugin.Isometric.Point3;
-		}
+        addIsoSprite(x: number, y: number, z: number, key?: any, frame?: any, group?: Phaser.Group): Phaser.Sprite;
 
-		class IsoSprite extends Phaser.Sprite{
-			snap: number;
-			constructor(game: Phaser.Game, x: number, y: number, z: number, key?: any, frame?: any);
+    }
 
-		}
-	}
+    module Isometric {
 
-}
\ No newline at end of file
+        class Projector {
+
+            game: Phaser.Game;
+            anchor: Phaser.Point;
+            projectionAngle: number;
+
+            project(point3: Phaser.Plugin.Isometric.Point3, out?: Phaser.Point): Phaser.Point;
+            projectXY(point3: Phaser.Plugin.Isometric.Point3, out?: Phaser.Point): Phaser.Point;
+            unproject(point: Phaser.Point, out?: Phaser.Plugin.Isometric.Point3, z?: number): Phaser.Plugin.Isometric.Point3;
+            simpleSort(group: Phaser.Group): void;
+            topologicalSort(group: Phaser.Group, padding?: number, prop?: string): void;
+
+        }
+
+        class Point3 {
+
+            static add(a: Phaser.Plugin.Isometric.Point3, b: Phaser.Plugin.Isometric.Point3, out?: Phaser.Plugin.Isometric.Point3): Phaser.Plugin.Isometric.Point3;
+            static subtract(a: Phaser.Plugin.Isometric.Point3, b: Phaser.Plugin.Isometric.Point3, out?: Phaser.Plugin.Isometric.Point3): Phaser.Plugin.Isometric.Point3;
+            static multiply(a: Phaser.Plugin.Isometric.Point3, b: Phaser.Plugin.Isometric.Point3, out?: Phaser.Plugin.Isometric.Point3): Phaser.Plugin.Isometric.Point3;
+            static divide(a: Phaser.Plugin.Isometric.Point3, b: Phaser.Plugin.Isometric.Point3, out?: Phaser.Plugin.Isometric.Point3): Phaser.Plugin.Isometric.Point3;
+            static equals(a: Phaser.Plugin.Isometric.Point3, b: Phaser.Plugin.Isometric.Point3): boolean;
+
+            x: number;
+            y: number;
+            z: number;
+
+            constructor(x?: number, y?: number, z?: number);
+
+            copyFrom(source: any): Phaser.Plugin.Isometric.Point3;
+            copyto(dest: any): any;
+            equals(a: any): boolean;
+            set(x?: number, y?: number, z?: number): Phaser.Plugin.Isometric.Point3;
+            setTo(x?: number, y?: number, z?: number): Phaser.Plugin.Isometric.Point3;
+            add(x?: number, y?: number): Phaser.Plugin.Isometric.Point3;
+            subtract(x?: number, y?: number, z?: number): Phaser.Plugin.Isometric.Point3;
+            multiply(x?: number, y?: number, z?: number): Phaser.Plugin.Isometric.Point3;
+            divide(x?: number, y?: number, z?: number): Phaser.Plugin.Isometric.Point3;
+
+        }
+
+        class Octree {
+
+            maxObjects: number;
+            maxLevels: number;
+            level: number;
+            bounds: any;
+            objects: any[];
+            nodes: any[];
+
+            constructor(x: number, y: number, z: number, widthX: number, widthY: number, height: number, maxObject?: number, maxLevels?: number, level?: number);
+
+            reset(x: number, y: number, z: number, widthX: number, widthY: number, height: number, maxObject?: number, maxLevels?: number, level?: number): void;
+            populate(group: Phaser.Group);
+            populateHandler(sprite: Phaser.Plugin.Isometric.IsoSprite): void;
+            populateHandler(sprite: any): void;
+            split(): void;
+            insert(body: Phaser.Plugin.Isometric.Body): void;
+            insert(body: Phaser.Plugin.Isometric.Cube): void;
+            insert(body: any): void;
+            getIndex(cube: Phaser.Plugin.Isometric.Cube): number;
+            getIndex(cube: any): number;
+            retrieve(source: Phaser.Plugin.Isometric.IsoSprite): any[];
+            retrieve(source: Phaser.Plugin.Isometric.Cube): any[];
+            clear(): void;
+
+        }
+
+        class IsoSprite extends Phaser.Sprite {
+
+            snap: number;
+            isoX: number;
+            isoY: number;
+            isoZ: number;
+            isoPosition: Phaser.Plugin.Isometric.Point3;
+            isoBounds: Phaser.Plugin.Isometric.Point3;
+            depth: number;
+
+            constructor(game: Phaser.Game, x: number, y: number, z: number, key?: any, frame?: any);
+
+            resetIsoBounds(): void;
+
+        }
+
+        class Cube {
+
+            static size(a: Phaser.Plugin.Isometric.Cube, output?: Phaser.Plugin.Isometric.Point3): Phaser.Plugin.Isometric.Point3;
+            static clone(a: Phaser.Plugin.Isometric.Cube, output?: Phaser.Plugin.Isometric.Cube): Phaser.Plugin.Isometric.Cube;
+            static contains(a: Phaser.Plugin.Isometric.Cube, x: number, y: number, z: number): boolean;
+            static containsXY(a: Phaser.Plugin.Isometric.Cube, x: number, y: number): boolean;
+            static containsPoint3(a: Phaser.Plugin.Isometric.Cube, point3: Phaser.Plugin.Isometric.Point3): boolean;
+            static containsCube(a: Phaser.Plugin.Isometric.Cube, b: Phaser.Plugin.Isometric.Cube): boolean;
+            static intersects(a: Phaser.Plugin.Isometric.Cube, b: Phaser.Plugin.Isometric.Cube): boolean;
+
+            x: number;
+            y: number;
+            z: number;
+            widthX: number;
+            widthY: number;
+            height: number;
+            halfWidthX: number;
+            halfWidthY: number;
+            halfHeight: number;
+            bottom: number;
+            top: number;
+            backX: number;
+            backY: number;
+            frontX: number;
+            frontY: number;
+            volume: number;
+            centerX: number;
+            centerY: number;
+            centerZ: number;
+            randomX: number;
+            randomY: number;
+            randomZ: number;
+            empty: boolean;
+
+            constructor(x?: number, y?: number, z?: number, widthX?: number, widthY?: number, height?: number);
+
+            setTo(x?: number, y?: number, z?: number, widthX?: number, widthY?: number, height?: number): Phaser.Plugin.Isometric.Cube;
+            copyFrom(source: any): Phaser.Plugin.Isometric.Cube;
+            copyTo(dest: any): Phaser.Plugin.Isometric.Cube;
+            size(output?: Phaser.Plugin.Isometric.Point3): Phaser.Plugin.Isometric.Point3;
+            contains(x: number, y: number, z: number): boolean;
+            containsXY(x: number, y: number): boolean;
+            clone(output?: Phaser.Plugin.Isometric.Cube): Phaser.Plugin.Isometric.Cube;
+            intersects(b: Phaser.Plugin.Isometric.Cube): boolean;
+            getCorners(): Phaser.Plugin.Isometric.Point3[];
+            toString(): string;
+
+        }
+
+        class Body {
+
+            static render(context: any, body: Phaser.Plugin.Isometric.Body, color?: string, filled?: boolean): void;
+            static renderBodyInfo(debug: any, body: Phaser.Plugin.Isometric.Body): void; //togo debug?
+
+            sprite: Phaser.Plugin.Isometric.IsoSprite;
+            game: Phaser.Game;
+            type: number;
+            enable: boolean;
+            offset: Phaser.Plugin.Isometric.Point3;
+            position: Phaser.Plugin.Isometric.Point3;
+            prev: Phaser.Plugin.Isometric.Point3;
+            allowRotation: boolean;
+            rotation: number;
+            preRotation: number;
+            sourceWidthX: number;
+            sourceWidthY: number;
+            sourceHeight: number;
+            widthX: number;
+            widthY: number;
+            height: number;
+            halfWidthX: number;
+            halfWidthY: number;
+            halfHeight: number;
+            center: Phaser.Plugin.Isometric.Point3;
+            velocity: Phaser.Plugin.Isometric.Point3;
+            newVelocity: Phaser.Plugin.Isometric.Point3;
+            deltaMax: Phaser.Plugin.Isometric.Point3;
+            acceleration: Phaser.Plugin.Isometric.Point3;
+            drag: Phaser.Plugin.Isometric.Point3;
+            allowGravity: boolean;
+            gravity: Phaser.Plugin.Isometric.Point3;
+            bounce: Phaser.Plugin.Isometric.Point3;
+            maxVelocity: Phaser.Plugin.Isometric.Point3;
+            angularVelocity: number;
+            angularAcceleration: number;
+            angularDrag: number;
+            maxAngular: number;
+            mass: number;
+            angle: number;
+            speed: number;
+            facing: number;
+            immovable: boolean;
+            moves: boolean;
+            customSeparateX: boolean;
+            customSeparateY: boolean;
+            customSeparateZ: boolean;
+            overlapX: number;
+            overlapY: number;
+            overlayZ: number;
+            embedded: boolean;
+            collideWorldBounds: boolean;
+            checkCollision: {
+                none: boolean;
+                any: boolean;
+                up: boolean;
+                down: boolean;
+                frontX: number;
+                frontY: number;
+                backX: number;
+                backY: number;
+            };
+            touching: {
+                none: boolean;
+                up: boolean;
+                down: boolean;
+                frontX: number;
+                frontY: number;
+                backX: number;
+                backY: number;
+            };
+            wasTouching: {
+                none: boolean;
+                up: boolean;
+                down: boolean;
+                frontX: number;
+                frontY: number;
+                backX: number;
+                backY: number;
+            };
+            blocked: {
+                up: boolean;
+                down: boolean;
+                frontX: number;
+                frontY: number;
+                backX: number;
+                backY: number;
+            };
+            phase: number;
+            skipTree: boolean;
+            top: number;
+            frontX: number;
+            right: number;
+            frontY: number;
+            bottom: number;
+            x: number;
+            y: number;
+            z: number;
+
+            constructor(sprite: Phaser.Plugin.Isometric.IsoSprite);
+
+            destroy(): void;
+            setSize(widthX: number, widthY: number, height: number, offsetX?: number, offsetY?: number, offsetZ?: number): void;
+            reset(x: number, y: number, z: number): void;
+            hitText(x: number, y: number, z: number): boolean;
+            onFloor(): boolean;
+            onWall(): boolean;
+            deltaAbsX(): number;
+            deltaAbsY(): number;
+            deltaAbsZ(): number;
+            deltaX(): number;
+            deltaY(): number;
+            deltaZ(): number;
+            deltaR(): number;
+            getCorners(): Phaser.Plugin.Isometric.Point3[];
+
+        }
+
+        class Arcade {
+
+            game: Phaser.Game;
+            gravity: Phaser.Plugin.Isometric.Point3;
+            bounds: Phaser.Plugin.Isometric.Cube;
+            checkCollision: {
+                up: boolean;
+                down: boolean;
+                frontX: boolean;
+                frontY: boolean;
+                backX: boolean;
+                backY: boolean;
+            };
+            maxObjects: number;
+            maxLevels: number;
+            OVERLAP_BIAS: number;
+            forceXY: boolean;
+            skipTree: boolean;
+            useQuadTree: boolean;
+            quadTree: Phaser.QuadTree;
+            octree: Phaser.Plugin.Isometric.Octree;
+
+            constructor(game: Phaser.Game);
+
+            setBounds(x: number, y: number, z: number, widthX: number, widthY: number, height: number): void;
+            setBoundsToWorld(): void;
+            enable(object: any, children?: boolean): void;
+            enableBody(object: any): void;
+            updateMotion(body: Phaser.Plugin.Isometric.Body): void;
+            computeVelocity(axis: number, body: Phaser.Plugin.Isometric.Body, velocity: number, acceleration: number, drag: number, max?: number): number;
+            overlap(object1: any, object2: any, overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
+            collide(object1: any, object2: any, overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
+            intersects(body1: Phaser.Plugin.Isometric.Body): boolean;
+            distanceBEtwee(source: any, target: any): number;
+            distanceToXY(displayObject: any, x: number, y: number): number;
+            distanceToXYZ(displayObject: any, x: number, y: number, z: number): number;
+
+        }
+
+    }
+
+}