diff --git a/pixi.js/pixi.js-tests.ts b/pixi.js/pixi.js-tests.ts
index 65fb7458a..309f7f66a 100644
--- a/pixi.js/pixi.js-tests.ts
+++ b/pixi.js/pixi.js-tests.ts
@@ -3,7 +3,7 @@
 function PixiTests()
 {
 
-var stage = new PIXI.Stage(0xFFFFFF, true);
+var stage = new PIXI.Stage(0xFFFFFF);
 
 stage.interactive = true;
 
@@ -70,15 +70,7 @@ var count = 0;
 
 stage.click = stage.tap = function()
 {
-	if(!container.filter)
-	{
-		container.mask = thing;
-		PIXI.runList(stage);
-	}
-	else
-	{
-		container.mask = null;
-	}
+	container.mask = null;
 }
 
 /*
@@ -136,15 +128,13 @@ function animate() {
 /* 13 */
 
 // create an new instance of a pixi stage
-var stage = new PIXI.Stage(0xFFFFFF, true);
-
-stage.setInteractive(true);
+var stage = new PIXI.Stage(0xFFFFFF);
 
 var sprite=  PIXI.Sprite.fromImage("spinObj_02.png");
 //stage.addChild(sprite);
 // create a renderer instance
 // the 5the parameter is the anti aliasing
-var renderer = PIXI.autoDetectRenderer(620, 380, null, false, true);
+var renderer = PIXI.autoDetectRenderer(620, 380);
 
 // set the canvas width and height to fill the screen
 //renderer.view.style.width = window.innerWidth + "px";
@@ -352,10 +342,7 @@ function init()
 	var assetsToLoader = ["desyrel.fnt"];
 
 	// create a new loader
-	var loader = new PIXI.AssetLoader(assetsToLoader);
-
-	// use callback
-	loader.onComplete = onAssetsLoaded;
+	var loader = new PIXI.AssetLoader(assetsToLoader, false);
 
 	//begin load
 
@@ -369,7 +356,6 @@ function init()
 		bitmapFontText.position.x = 620 - bitmapFontText.width - 20;
 		bitmapFontText.position.y = 20;
 
-		PIXI.runList(bitmapFontText)
 		stage.addChild(bitmapFontText);
 
 
@@ -439,7 +425,7 @@ function init()
 
 
 // create an new instance of a pixi stage
-var stage = new PIXI.Stage(0x97c56e, true);
+var stage = new PIXI.Stage(0x97c56e);
 
 // create a renderer instance
 var renderer = PIXI.autoDetectRenderer(window.innerWidth, window.innerHeight, null);
@@ -487,7 +473,7 @@ function animate33() {
 
 
 // create an new instance of a pixi stage
-var stage = new PIXI.Stage(0x97c56e, true);
+var stage = new PIXI.Stage(0x97c56e);
 
 // create a renderer instance
 var renderer = PIXI.autoDetectRenderer(window.innerWidth, window.innerHeight, null);
@@ -586,7 +572,7 @@ function animate44() {
 var stage = new PIXI.Stage(0x66FF99);
 
 // create a renderer instance
-var renderer = PIXI.autoDetectRenderer(400, 300, null, true);
+var renderer = PIXI.autoDetectRenderer(400, 300, null);
 
 // add the renderer view element to the DOM
 document.body.appendChild(renderer.view);
@@ -630,7 +616,7 @@ function animate55() {
 // create an new instance of a pixi stage
 // the second parameter is interactivity...
 var interactive = true;
-var stage = new PIXI.Stage(0x000000, interactive);
+var stage = new PIXI.Stage(0x000000);
 
 // create a renderer instance.
 var renderer = PIXI.autoDetectRenderer(620, 400);
@@ -765,8 +751,6 @@ stage.addChild(pixiLogo);
 pixiLogo.position.x = 620 - 56;
 pixiLogo.position.y = 400- 32;
 
-pixiLogo.setInteractive(true);
-
 pixiLogo.click = pixiLogo.tap = function(){
 
 	var win=window.open("https://github.com/GoodBoyDigital/pixi.js", '_blank');
diff --git a/pixi.js/pixi.js.d.ts b/pixi.js/pixi.js.d.ts
index c86c1bd47..0452e7432 100644
--- a/pixi.js/pixi.js.d.ts
+++ b/pixi.js/pixi.js.d.ts
@@ -1,448 +1,1912 @@
-// Type definitions for PIXI 1.3
+// Type definitions for PIXI 2.2.8 2015-03-24
 // Project: https://github.com/GoodBoyDigital/pixi.js/
-// Definitions by: xperiments <http://github.com/xperiments>
+// Definitions by: clark-stevenson <https://github.com/pixijs/pixi-typescript>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-declare module PIXI
-{
+declare module PIXI {
 
-    /* STATICS */
-    export var gl:WebGLRenderingContext;
-    export var BaseTextureCache: {};
-    export var texturesToUpdate: BaseTexture[];
-    export var texturesToDestroy: BaseTexture[];
-    export var TextureCache: {};
-    export var FrameCache: {};
-    export var blendModes:{ NORMAL:number; SCREEN:number; };
+    export var WEBGL_RENDERER: number;
+    export var CANVAS_RENDERER: number;
+    export var VERSION: string;
 
+    export enum blendModes {
 
-    /* MODULE FUNCTIONS */
-    export function autoDetectRenderer(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean, antialias?: boolean): IPixiRenderer;
-    export function FilterBlock( mask:Graphics ):void;
-    export function MaskFilter( graphics:Graphics ):void;
+        NORMAL,
+        ADD,
+        MULTIPLY,
+        SCREEN,
+        OVERLAY,
+        DARKEN,
+        LIGHTEN,
+        COLOR_DODGE,
+        COLOR_BURN,
+        HARD_LIGHT,
+        SOFT_LIGHT,
+        DIFFERENCE,
+        EXCLUSION,
+        HUE,
+        SATURATION,
+        COLOR,
+        LUMINOSITY
 
-
-    /* DEBUG METHODS */
-
-    export function runList( x ):void;
-
-    /*INTERFACES*/
-
-    export interface IBasicCallback
-    {
-        ():void
     }
 
-    export interface IEvent
-    {
+    export enum scaleModes {
+
+        DEFAULT,
+        LINEAR,
+        NEAREST
+
+    }
+
+    export var defaultRenderOptions: PixiRendererOptions;
+
+    export var INTERACTION_REQUENCY: number;
+    export var AUTO_PREVENT_DEFAULT: boolean;
+
+    export var PI_2: number;
+    export var RAD_TO_DEG: number;
+    export var DEG_TO_RAD: number;
+
+    export var RETINA_PREFIX: string;
+    export var identityMatrix: Matrix;
+    export var glContexts: WebGLRenderingContext[];
+    export var instances: any[];
+
+    export var BaseTextureCache: { [key: string]: BaseTexture }
+    export var TextureCache: { [key: string]: Texture }
+
+    export function isPowerOfTwo(width: number, height: number): boolean;
+
+    export function rgb2hex(rgb: number[]): string;
+    export function hex2rgb(hex: string): number[];
+
+    export function autoDetectRenderer(width?: number, height?: number, options?: PixiRendererOptions): PixiRenderer;
+    export function autoDetectRecommendedRenderer(width?: number, height?: number, options?: PixiRendererOptions): PixiRenderer;
+
+    export function canUseNewCanvasBlendModes(): boolean;
+    export function getNextPowerOfTwo(number: number): number;
+
+    export function AjaxRequest(): XMLHttpRequest;
+
+    export function CompileFragmentShader(gl: WebGLRenderingContext, shaderSrc: string[]): any;
+    export function CompileProgram(gl: WebGLRenderingContext, vertexSrc: string[], fragmentSrc: string[]): any;
+
+
+    export interface IEventCallback {
+        (e?: IEvent): void
+    }
+
+    export interface IEvent {
         type: string;
         content: any;
     }
 
-    export interface IHitArea
-    {
-        contains(x: number, y: number):boolean;
+    export interface HitArea {
+        contains(x: number, y: number): boolean;
     }
 
-    export interface IInteractionDataCallback
-    {
-        (interactionData: InteractionData):void
+    export interface IInteractionDataCallback {
+        (interactionData: InteractionData): void
     }
 
-    export interface IPixiRenderer
-    {
+    export interface PixiRenderer {
+
+        autoResize: boolean;
+        clearBeforeRender: boolean;
+        height: number;
+        resolution: number;
+        transparent: boolean;
+        type: number;
         view: HTMLCanvasElement;
+        width: number;
+
+        destroy(): void;
         render(stage: Stage): void;
+        resize(width: number, height: number): void;
+
     }
 
-    export interface IBitmapTextStyle
-    {
+    export interface PixiRendererOptions {
+
+        autoResize?: boolean;
+        antialias?: boolean;
+        clearBeforeRender?: boolean;
+        preserveDrawingBuffer?: boolean;
+        resolution?: number;
+        transparent?: boolean;
+        view?: HTMLCanvasElement;
+
+    }
+
+    export interface BitmapTextStyle {
+
         font?: string;
         align?: string;
+        tint?: string;
+
     }
 
-    export interface ITextStyle
-    {
-        font?: string;
-        stroke?: string;
+    export interface TextStyle {
+
+        align?: string;
+        dropShadow?: boolean;
+        dropShadowColor?: string;
+        dropShadowAngle?: number;
+        dropShadowDistance?: number;
         fill?: string;
-        align?: string;
+        font?: string;
+        lineJoin?: string;
+        stroke?: string;
         strokeThickness?: number;
         wordWrap?: boolean;
-        wordWrapWidth?:number;
+        wordWrapWidth?: number;
+
     }
 
+    export interface Loader {
 
-
-    /* CLASES */
-
-    export class AssetLoader extends EventTarget
-    {
-        assetURLs: string[];
-        onComplete: IBasicCallback;
-        onProgress: IBasicCallback;
-        constructor(assetURLs: string[], crossorigin?:boolean );
         load(): void;
+
     }
 
-    export class BaseTexture extends EventTarget
-    {
+    export interface MaskData {
+
+        alpha: number;
+        worldTransform: number[];
+
+    }
+
+    export interface RenderSession {
+
+        context: CanvasRenderingContext2D;
+        maskManager: CanvasMaskManager;
+        scaleMode: scaleModes;
+        smoothProperty: string;
+        roundPixels: boolean;
+
+    }
+
+    export interface ShaderAttribute {
+        // TODO: Find signature of shader attributes
+    }
+
+    export interface FilterBlock {
+
+        visible: boolean;
+        renderable: boolean;
+
+    }
+
+    export class AbstractFilter {
+
+        constructor(fragmentSrc: string[], uniforms: any);
+
+        dirty: boolean;
+        padding: number;
+        uniforms: any;
+        fragmentSrc: string[];
+
+        apply(frameBuffer: WebGLFramebuffer): void;
+        syncUniforms(): void;
+
+    }
+
+    export class AlphaMaskFilter extends AbstractFilter {
+
+        constructor(texture: Texture);
+
+        map: Texture;
+
+        onTextureLoaded(): void;
+
+    }
+
+    export class AsciiFilter extends AbstractFilter {
+
+        size: number;
+
+    }
+
+    export class AssetLoader implements Mixin {
+
+        assetURLs: string[];
+        crossorigin: boolean;
+        loadersByType: { [key: string]: Loader };
+
+        constructor(assetURLs: string[], crossorigin?: boolean);
+
+        listeners(eventName: string): Function[];
+        emit(eventName: string, data?: any): boolean;
+        dispatchEvent(eventName: string, data?: any): boolean;
+        on(eventName: string, fn: Function): Function;
+        addEventListener(eventName: string, fn: Function): Function;
+        once(eventName: string, fn: Function): Function;
+        off(eventName: string, fn: Function): Function;
+        removeAllEventListeners(eventName: string): void;
+
+        load(): void;
+
+
+    }
+
+    export class AtlasLoader implements Mixin {
+
+        url: string;
+        baseUrl: string;
+        crossorigin: boolean;
+        loaded: boolean;
+
+        constructor(url: string, crossorigin: boolean);
+
+        listeners(eventName: string): Function[];
+        emit(eventName: string, data?: any): boolean;
+        dispatchEvent(eventName: string, data?: any): boolean;
+        on(eventName: string, fn: Function): Function;
+        addEventListener(eventName: string, fn: Function): Function;
+        once(eventName: string, fn: Function): Function;
+        off(eventName: string, fn: Function): Function;
+        removeAllEventListeners(eventName: string): void;
+
+        load(): void;
+
+    }
+
+    export class BaseTexture implements Mixin {
+
+        static fromImage(imageUrl: string, crossorigin?: boolean, scaleMode?: scaleModes): BaseTexture;
+        static fromCanvas(canvas: HTMLCanvasElement, scaleMode?: scaleModes): BaseTexture;
+
+        constructor(source: HTMLImageElement, scaleMode: scaleModes);
+        constructor(source: HTMLCanvasElement, scaleMode: scaleModes);
+
         height: number;
+        hasLoaded: boolean;
+        mipmap: boolean;
+        premultipliedAlpha: boolean;
+        resolution: number;
+        scaleMode: scaleModes;
+        source: HTMLImageElement;
         width: number;
-        source: string;
 
-        constructor(source: HTMLImageElement);
-        constructor(source: HTMLCanvasElement);
-        destroy():void;
+        listeners(eventName: string): Function[];
+        emit(eventName: string, data?: any): boolean;
+        dispatchEvent(eventName: string, data?: any): boolean;
+        on(eventName: string, fn: Function): Function;
+        addEventListener(eventName: string, fn: Function): Function;
+        once(eventName: string, fn: Function): Function;
+        off(eventName: string, fn: Function): Function;
+        removeAllEventListeners(eventName: string): void;
+
+        destroy(): void;
+        dirty(): void;
+        updateSourceImage(newSrc: string): void;
+        unloadFromGPU(): void;
 
-        static fromImage(imageUrl: string, crossorigin?:boolean ): BaseTexture;
     }
 
-    export class BitmapFontLoader extends EventTarget
-    {
-        baseUrl:string;
-        crossorigin:boolean;
-        texture:Texture;
-        url:string;
-        constructor(url: string, crossorigin?: boolean);
-        load():void;
+    export class BitmapFontLoader implements Mixin {
+
+        constructor(url: string, crossorigin: boolean);
+
+        baseUrl: string;
+        crossorigin: boolean;
+        texture: Texture;
+        url: string;
+
+        listeners(eventName: string): Function[];
+        emit(eventName: string, data?: any): boolean;
+        dispatchEvent(eventName: string, data?: any): boolean;
+        on(eventName: string, fn: Function): Function;
+        addEventListener(eventName: string, fn: Function): Function;
+        once(eventName: string, fn: Function): Function;
+        off(eventName: string, fn: Function): Function;
+        removeAllEventListeners(eventName: string): void;
+
+        load(): void;
+
     }
 
-    export class BitmapText extends DisplayObjectContainer
-    {
-        width:number;
-        height:number;
-        constructor(text: string, style: IBitmapTextStyle);
-        setStyle(style: IBitmapTextStyle): void;
+    export class BitmapText extends DisplayObjectContainer {
+
+        static fonts: any;
+
+        constructor(text: string, style: BitmapTextStyle);
+
+        dirty: boolean;
+        fontName: string;
+        fontSize: number;
+        maxWidth: number;
+        textWidth: number;
+        textHeight: number;
+        tint: number;
+        style: BitmapTextStyle;
+
         setText(text: string): void;
+        setStyle(style: BitmapTextStyle): void;
+
     }
 
-    export class CanvasRenderer implements IPixiRenderer
-    {
+    export class BlurFilter extends AbstractFilter {
+
+        blur: number;
+        blurX: number;
+        blurY: number;
+
+    }
+
+    export class BlurXFilter extends AbstractFilter {
+
+        blur: number;
+
+    }
+
+    export class BlurYFilter extends AbstractFilter {
+
+        blur: number;
+
+    }
+
+    export class CanvasBuffer {
+
+        constructor(width: number, height: number);
+
+        canvas: HTMLCanvasElement;
         context: CanvasRenderingContext2D;
         height: number;
-        view: HTMLCanvasElement;
         width: number;
-        constructor(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean);
-        render(stage: Stage): void;
-        resize(width: number, height: number):void;
+
+        clear(): void;
+        resize(width: number, height: number): void;
+
     }
 
-    export class Circle implements IHitArea
-    {
+    export class CanvasMaskManager {
+
+        pushMask(maskData: MaskData, renderSession: RenderSession): void;
+        popMask(renderSession: RenderSession): void;
+
+    }
+
+    export class CanvasRenderer implements PixiRenderer {
+
+        constructor(width?: number, height?: number, options?: PixiRendererOptions);
+
+        autoResize: boolean;
+        clearBeforeRender: boolean;
+        context: CanvasRenderingContext2D;
+        count: number;
+        height: number;
+        maskManager: CanvasMaskManager;
+        refresh: boolean;
+        renderSession: RenderSession;
+        resolution: number;
+        transparent: boolean;
+        type: number;
+        view: HTMLCanvasElement;
+        width: number;
+
+        destroy(removeView?: boolean): void;
+        render(stage: Stage): void;
+        resize(width: number, height: number): void;
+
+    }
+
+    export class CanvasTinter {
+
+        static getTintedTexture(sprite: Sprite, color: number): HTMLCanvasElement;
+        static tintWithMultiply(texture: Texture, color: number, canvas: HTMLCanvasElement): void;
+        static tintWithOverlay(texture: Texture, color: number, canvas: HTMLCanvasElement): void;
+        static tintWithPerPixel(texture: Texture, color: number, canvas: HTMLCanvasElement): void;
+        static roundColor(color: number): void;
+
+        static cacheStepsPerColorChannel: number;
+        static convertTintToImage: boolean;
+        static canUseMultiply: boolean;
+        static tintMethod: any;
+
+    }
+
+    export class Circle implements HitArea {
+
+        constructor(x: number, y: number, radius: number);
+
         x: number;
         y: number;
         radius: number;
-        constructor(x: number, y: number, radius: number);
+
         clone(): Circle;
-        contains(x: number, y: number):boolean;
+        contains(x: number, y: number): boolean;
+        getBounds(): Rectangle;
+
     }
 
-    // TODO what is renderGroup
-    export class CustomRenderable extends DisplayObject
-    {
-        constructor();
-        renderCanvas(renderer: CanvasRenderer): void;
-        initWebGL(renderer: WebGLRenderer): void;
-        renderWebGL(renderGroup: any, projectionMatrix: any): void;
+    export class ColorMatrixFilter extends AbstractFilter {
+
+        matrix: Matrix;
+
     }
 
-    export class DisplayObject
-    {
-        x: number;
-        y: number;
+    export class ColorStepFilter extends AbstractFilter {
+
+        step: number;
+
+    }
+
+    export class ConvolutionFilter extends AbstractFilter {
+
+        constructor(matrix: number[], width: number, height: number);
+
+        matrix: Matrix;
+        width: number;
+        height: number;
+
+    }
+
+    export class CrossHatchFilter extends AbstractFilter {
+
+        blur: number;
+
+    }
+
+    export class DisplacementFilter extends AbstractFilter {
+
+        constructor(texture: Texture);
+
+        map: Texture;
+        offset: Point;
+        scale: Point;
+
+    }
+
+    export class DotScreenFilter extends AbstractFilter {
+
+        angle: number;
+        scale: Point;
+
+    }
+
+    export class DisplayObject {
+
         alpha: number;
         buttonMode: boolean;
-        filter:boolean;
-        hitArea: IHitArea;
+        cacheAsBitmap: boolean;
+        defaultCursor: string;
+        filterArea: Rectangle;
+        filters: AbstractFilter[];
+        hitArea: HitArea;
+        interactive: boolean;
+        mask: Graphics;
         parent: DisplayObjectContainer;
         pivot: Point;
         position: Point;
-        rotation: number;
         renderable: boolean;
+        rotation: number;
         scale: Point;
         stage: Stage;
         visible: boolean;
         worldAlpha: number;
-        constructor();
-        static autoDetectRenderer(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean): IPixiRenderer;
-        click: IInteractionDataCallback;
-        mousedown: IInteractionDataCallback;
-        mouseout: IInteractionDataCallback;
-        mouseover: IInteractionDataCallback;
-        mouseup: IInteractionDataCallback;
-        mouseupoutside: IInteractionDataCallback;
-        mousemove: IInteractionDataCallback;
-        tap: IInteractionDataCallback;
-        touchend: IInteractionDataCallback;
-        touchendoutside: IInteractionDataCallback;
-        touchstart: IInteractionDataCallback;
-        touchmove: IInteractionDataCallback;
+        worldVisible: boolean;
+        x: number;
+        y: number;
 
-        //deprecated
-        setInteractive(interactive: boolean): void;
+        click(e: InteractionData): void;
+        displayObjectUpdateTransform(): void;
+        getBounds(matrix?: Matrix): Rectangle;
+        getLocalBounds(): Rectangle;
+        generateTexture(resolution: number, scaleMode: scaleModes, renderer: PixiRenderer): RenderTexture;
+        mousedown(e: InteractionData): void;
+        mouseout(e: InteractionData): void;
+        mouseover(e: InteractionData): void;
+        mouseup(e: InteractionData): void;
+        mousemove(e: InteractionData): void;
+        mouseupoutside(e: InteractionData): void;
+        rightclick(e: InteractionData): void;
+        rightdown(e: InteractionData): void;
+        rightup(e: InteractionData): void;
+        rightupoutside(e: InteractionData): void;
+        setStageReference(stage: Stage): void;
+        tap(e: InteractionData): void;
+        toGlobal(position: Point): Point;
+        toLocal(position: Point, from: DisplayObject): Point;
+        touchend(e: InteractionData): void;
+        touchendoutside(e: InteractionData): void;
+        touchstart(e: InteractionData): void;
+        touchmove(e: InteractionData): void;
+        updateTransform(): void;
 
-        // getters setters
-        interactive:boolean;
-        mask:Graphics;
     }
 
-    export class DisplayObjectContainer extends DisplayObject
-    {
+    export class DisplayObjectContainer extends DisplayObject {
+
+        constructor();
+
         children: DisplayObject[];
-        constructor();
+        height: number;
+        width: number;
 
-        addChild(child: DisplayObject): void;
-        addChildAt(child: DisplayObject, index: number): void;
-        getChildAt(index:number):DisplayObject;
-        removeChild(child: DisplayObject): void;
+        addChild(child: DisplayObject): DisplayObject;
+        addChildAt(child: DisplayObject, index: number): DisplayObject;
+        getBounds(): Rectangle;
+        getChildAt(index: number): DisplayObject;
+        getChildIndex(child: DisplayObject): number;
+        getLocalBounds(): Rectangle;
+        removeChild(child: DisplayObject): DisplayObject;
+        removeChildAt(index: number): DisplayObject;
+        removeChildren(beginIndex?: number, endIndex?: number): DisplayObject[];
+        removeStageReference(): void;
+        setChildIndex(child: DisplayObject, index: number): void;
         swapChildren(child: DisplayObject, child2: DisplayObject): void;
+
     }
 
-    export class Ellipse implements IHitArea
-    {
+    export class Ellipse implements HitArea {
+
+        constructor(x: number, y: number, width: number, height: number);
+
         x: number;
         y: number;
         width: number;
         height: number;
 
-        constructor(x: number, y: number, width: number, height: number);
         clone(): Ellipse;
-        contains(x: number, y: number):boolean;
-        getBounds():Rectangle;
+        contains(x: number, y: number): boolean;
+        getBounds(): Rectangle;
+
     }
 
-    export class EventTarget
-    {
-        addEventListener(type: string, listener: (event: IEvent) => void );
-        removeEventListener(type: string, listener: (event: IEvent) => void );
-        dispatchEvent(event: IEvent);
+    export class Event {
+
+        constructor(target: any, name: string, data: any);
+
+        target: any;
+        type: string;
+        data: any;
+        timeStamp: number;
+
+        stopPropagation(): void;
+        preventDefault(): void;
+        stopImmediatePropagation(): void;
+
     }
 
-    export class Graphics extends DisplayObjectContainer
-    {
-        lineWidth:number;
-        lineColor:string;
-        constructor();
+    export class EventTarget {
+
+        static mixin(obj: any): void;
+
+    }
+
+    export class FilterTexture {
+
+        constructor(gl: WebGLRenderingContext, width: number, height: number, scaleMode: scaleModes);
+
+        fragmentSrc: string[];
+        frameBuffer: WebGLFramebuffer;
+        gl: WebGLRenderingContext;
+        program: WebGLProgram;
+        scaleMode: number;
+        texture: WebGLTexture;
 
-        beginFill(color?: number, alpha?: number): void;
         clear(): void;
-        drawCircle(x: number, y: number, radius: number): void;
-        drawElipse(x: number, y: number, width: number, height: number): void;
-        drawRect(x: number, y: number, width: number, height: number): void;
-        endFill(): void;
-        lineStyle(lineWidth?: number, color?: number, alpha?: number ): void;
-        lineTo(x: number, y: number): void;
-        moveTo(x: number, y: number): void;
+        resize(width: number, height: number): void;
+        destroy(): void;
 
-        static POLY:number;
-        static RECT:number;
-        static CIRC:number;
-        static ELIP:number;
     }
 
-    export class ImageLoader extends EventTarget
-    {
-        texture:Texture;
+    export class GraphicsData {
+
+        constructor(lineWidth?: number, lineColor?: number, lineAlpha?: number, fillColor?: number, fillAlpha?: number, fill?: boolean, shape?: any);
+
+        lineWidth: number;
+        lineColor: number;
+        lineAlpha: number;
+        fillColor: number;
+        fillAlpha: number;
+        fill: boolean;
+        shape: any;
+        type: number;
+
+    }
+
+    export class Graphics extends DisplayObjectContainer {
+
+        static POLY: number;
+        static RECT: number;
+        static CIRC: number;
+        static ELIP: number;
+        static RREC: number;
+
+        blendMode: number;
+        boundsPadding: number;
+        fillAlpha: number;
+        isMask: boolean;
+        lineWidth: number;
+        lineColor: number;
+        tint: number;
+        worldAlpha: number;
+
+        arc(cx: number, cy: number, radius: number, startAngle: number, endAngle: number, anticlockwise: boolean): Graphics;
+        arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): Graphics;
+        beginFill(color?: number, alpha?: number): Graphics;
+        bezierCurveTo(cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number): Graphics;
+        clear(): Graphics;
+        destroyCachedSprite(): void;
+        drawCircle(x: number, y: number, radius: number): Graphics;
+        drawEllipse(x: number, y: number, width: number, height: number): Graphics;
+        drawPolygon(...path: any[]): Graphics;
+        drawRect(x: number, y: number, width: number, height: number): Graphics;
+        drawRoundedRect(x: number, y: number, width: number, height: number, radius: number): Graphics;
+        drawShape(shape: Circle): GraphicsData;
+        drawShape(shape: Rectangle): GraphicsData;
+        drawShape(shape: Ellipse): GraphicsData;
+        drawShape(shape: Polygon): GraphicsData;
+        endFill(): Graphics;
+        lineStyle(lineWidth?: number, color?: number, alpha?: number): Graphics;
+        lineTo(x: number, y: number): Graphics;
+        moveTo(x: number, y: number): Graphics;
+        quadraticCurveTo(cpX: number, cpY: number, toX: number, toY: number): Graphics;
+
+    }
+
+    export class GrayFilter extends AbstractFilter {
+
+        gray: number;
+
+    }
+
+    export class ImageLoader implements Mixin {
+
         constructor(url: string, crossorigin?: boolean);
+
+        texture: Texture;
+
+        listeners(eventName: string): Function[];
+        emit(eventName: string, data?: any): boolean;
+        dispatchEvent(eventName: string, data?: any): boolean;
+        on(eventName: string, fn: Function): Function;
+        addEventListener(eventName: string, fn: Function): Function;
+        once(eventName: string, fn: Function): Function;
+        off(eventName: string, fn: Function): Function;
+        removeAllEventListeners(eventName: string): void;
+
         load(): void;
+        loadFramedSpriteSheet(frameWidth: number, frameHeight: number, textureName: string): void;
+
     }
 
-    /* TODO determine type of originalEvent*/
-    export class InteractionData
-    {
+    export class InteractionData {
+
         global: Point;
         target: Sprite;
-        constructor();
-        originalEvent:any;
-        getLocalPosition(displayObject: DisplayObject): Point;
+        originalEvent: Event;
+
+        getLocalPosition(displayObject: DisplayObject, point?: Point, globalPos?: Point): Point;
+
     }
 
-    export class InteractionManager
-    {
+    export class InteractionManager {
+
+        currentCursorStyle: string;
+        last: number;
         mouse: InteractionData;
+        mouseOut: boolean;
+        mouseoverEnabled: boolean;
+        onMouseMove: Function;
+        onMouseDown: Function;
+        onMouseOut: Function;
+        onMouseUp: Function;
+        onTouchStart: Function;
+        onTouchEnd: Function;
+        onTouchMove: Function;
+        pool: InteractionData[];
+        resolution: number;
         stage: Stage;
-        touchs:{ [id:string]:InteractionData };
+        touches: { [id: string]: InteractionData };
+
         constructor(stage: Stage);
     }
 
-    export class JsonLoader extends EventTarget
-    {
-        url:string;
-        crossorigin: boolean;
-        baseUrl:string;
-        loaded:boolean;
-        constructor(url: string, crossorigin?: boolean);
-        load(): void;
+    export class InvertFilter extends AbstractFilter {
+
+        invert: number;
+
     }
 
-    export class MovieClip extends Sprite
-    {
+    export class JsonLoader implements Mixin {
+
+        constructor(url: string, crossorigin?: boolean);
+
+        baseUrl: string;
+        crossorigin: boolean;
+        loaded: boolean;
+        url: string;
+
+        listeners(eventName: string): Function[];
+        emit(eventName: string, data?: any): boolean;
+        dispatchEvent(eventName: string, data?: any): boolean;
+        on(eventName: string, fn: Function): Function;
+        addEventListener(eventName: string, fn: Function): Function;
+        once(eventName: string, fn: Function): Function;
+        off(eventName: string, fn: Function): Function;
+        removeAllEventListeners(eventName: string): void;
+
+        load(): void;
+
+    }
+
+    export class Matrix {
+
+        a: number;
+        b: number;
+        c: number;
+        d: number;
+        tx: number;
+        ty: number;
+
+        append(matrix: Matrix): Matrix;
+        apply(pos: Point, newPos: Point): Point;
+        applyInverse(pos: Point, newPos: Point): Point;
+        determineMatrixArrayType(): number[];
+        identity(): Matrix;
+        rotate(angle: number): Matrix;
+        fromArray(array: number[]): void;
+        translate(x: number, y: number): Matrix;
+        toArray(transpose: boolean): number[];
+        scale(x: number, y: number): Matrix;
+
+    }
+
+    export interface Mixin {
+
+        listeners(eventName: string): Function[];
+        emit(eventName: string, data?: any): boolean;
+        dispatchEvent(eventName: string, data?: any): boolean;
+        on(eventName: string, fn: Function): Function;
+        addEventListener(eventName: string, fn: Function): Function;
+        once(eventName: string, fn: Function): Function;
+        off(eventName: string, fn: Function): Function;
+        removeAllEventListeners(eventName: string): void;
+
+    }
+
+    export class MovieClip extends Sprite {
+
+        static fromFrames(frames: string[]): MovieClip;
+        static fromImages(images: HTMLImageElement[]): HTMLImageElement;
+
+        constructor(textures: Texture[]);
+
         animationSpeed: number;
-        currentFrame:number;
+        currentFrame: number;
         loop: boolean;
         playing: boolean;
         textures: Texture[];
-        constructor(textures: Texture[]);
-        onComplete:IBasicCallback;
+        totalFrames: number;
+
         gotoAndPlay(frameNumber: number): void;
         gotoAndStop(frameNumber: number): void;
+        onComplete(): void;
         play(): void;
         stop(): void;
+
     }
 
-    export class Point
-    {
+    export class NoiseFilter extends AbstractFilter {
+
+        noise: number;
+
+    }
+
+    export class NormalMapFilter extends AbstractFilter {
+
+        map: Texture;
+        offset: Point;
+        scale: Point;
+
+    }
+
+    export class PixelateFilter extends AbstractFilter {
+
+        size: number;
+
+    }
+
+    export interface IPixiShader {
+
+        fragmentSrc: string[];
+        gl: WebGLRenderingContext;
+        program: WebGLProgram;
+        vertexSrc: string[];
+
+        destroy(): void;
+        init(): void;
+
+    }
+
+    export class PixiShader implements IPixiShader {
+
+        constructor(gl: WebGLRenderingContext);
+
+        attributes: ShaderAttribute[];
+        defaultVertexSrc: string[];
+        dirty: boolean;
+        firstRun: boolean;
+        textureCount: number;
+        fragmentSrc: string[];
+        gl: WebGLRenderingContext;
+        program: WebGLProgram;
+        vertexSrc: string[];
+
+        initSampler2D(): void;
+        initUniforms(): void;
+        syncUniforms(): void;
+
+        destroy(): void;
+        init(): void;
+
+    }
+
+    export class PixiFastShader implements IPixiShader {
+
+        constructor(gl: WebGLRenderingContext);
+
+        textureCount: number;
+        fragmentSrc: string[];
+        gl: WebGLRenderingContext;
+        program: WebGLProgram;
+        vertexSrc: string[];
+
+        destroy(): void;
+        init(): void;
+
+    }
+
+    export class PrimitiveShader implements IPixiShader {
+
+        constructor(gl: WebGLRenderingContext);
+        fragmentSrc: string[];
+        gl: WebGLRenderingContext;
+        program: WebGLProgram;
+        vertexSrc: string[];
+
+        destroy(): void;
+        init(): void;
+
+    }
+
+    export class ComplexPrimitiveShader implements IPixiShader {
+
+        constructor(gl: WebGLRenderingContext);
+        fragmentSrc: string[];
+        gl: WebGLRenderingContext;
+        program: WebGLProgram;
+        vertexSrc: string[];
+
+        destroy(): void;
+        init(): void;
+
+    }
+
+    export class StripShader implements IPixiShader {
+
+        constructor(gl: WebGLRenderingContext);
+        fragmentSrc: string[];
+        gl: WebGLRenderingContext;
+        program: WebGLProgram;
+        vertexSrc: string[];
+
+        destroy(): void;
+        init(): void;
+
+    }
+
+    export class Point {
+
+        constructor(x?: number, y?: number);
+
         x: number;
         y: number;
-        constructor(x: number, y: number);
+
         clone(): Point;
+        set(x: number, y: number): void;
+
     }
 
-    export class Polygon implements IHitArea
-    {
-        points: Point[];
+    export class Polygon implements HitArea {
 
         constructor(points: Point[]);
         constructor(points: number[]);
         constructor(...points: Point[]);
         constructor(...points: number[]);
 
+        points: any[]; //number[] Point[]
+
         clone(): Polygon;
-        contains( x:number, y:number ):boolean;
+        contains(x: number, y: number): boolean;
+
     }
 
-    export class Rectangle implements IHitArea
-    {
+    export class Rectangle implements HitArea {
+
+        constructor(x?: number, y?: number, width?: number, height?: number);
+
         x: number;
         y: number;
         width: number;
         height: number;
-        constructor(x: number, y: number, width: number, height: number);
+
         clone(): Rectangle;
-        contains(x: number, y: number):boolean;
+        contains(x: number, y: number): boolean;
+
     }
 
-    export class RenderTexture extends Texture
-    {
-        constructor(width: number, height: number);
-        resize(width: number, height: number): void;
+    export class RGBSplitFilter extends AbstractFilter {
+
+        red: Point;
+        green: Point;
+        blue: Point;
+
     }
 
-    export class Sprite extends DisplayObjectContainer
-    {
-        anchor: Point;
-        blendMode: number;
-        texture: Texture;
+    export class Rope extends Strip {
 
-        //getters setters
-        height: number;
+        points: Point[];
+        vertices: number[];
+
+        constructor(texture: Texture, points: Point[]);
+
+        refresh(): void;
+        setTexture(texture: Texture): void;
+
+    }
+
+    export class RoundedRectangle implements HitArea {
+
+        constructor(x?: number, y?: number, width?: number, height?: number, radius?: number);
+
+        x: number;
+        y: number;
         width: number;
+        height: number;
+        radius: number;
+
+        clone(): RoundedRectangle;
+        contains(x: number, y: number): boolean;
+
+    }
+
+    export class SepiaFilter extends AbstractFilter {
+
+        sepia: number;
+
+    }
+
+    export class SmartBlurFilter extends AbstractFilter {
+
+        blur: number;
+
+    }
+
+    export class SpineLoader implements Mixin {
+
+        url: string;
+        crossorigin: boolean;
+        loaded: boolean;
+
+        constructor(url: string, crossOrigin: boolean);
+
+        listeners(eventName: string): Function[];
+        emit(eventName: string, data?: any): boolean;
+        dispatchEvent(eventName: string, data?: any): boolean;
+        on(eventName: string, fn: Function): Function;
+        addEventListener(eventName: string, fn: Function): Function;
+        once(eventName: string, fn: Function): Function;
+        off(eventName: string, fn: Function): Function;
+        removeAllEventListeners(eventName: string): void;
+
+        load(): void;
+
+    }
+
+    export class SpineTextureLoader {
+
+        constructor(basePath: string, crossorigin: boolean);
+
+        load(page: AtlasPage, file: string): void;
+        unload(texture: BaseTexture): void;
+
+    }
+
+    export class Sprite extends DisplayObjectContainer {
+
+        static fromFrame(frameId: string): Sprite;
+        static fromImage(url: string, crossorigin?: boolean, scaleMode?: scaleModes): Sprite;
 
         constructor(texture: Texture);
 
-        static fromFrame(frameId: string): Sprite;
-        static fromImage(url: string): Sprite;
+        anchor: Point;
+        blendMode: blendModes;
+        shader: IPixiShader;
+        texture: Texture;
+        tint: number;
+
         setTexture(texture: Texture): void;
+
     }
 
-    /* TODO determine type of frames */
-    export class SpriteSheetLoader extends EventTarget
-    {
-        url:string;
-        crossorigin:boolean;
-        baseUrl:string;
-        texture:Texture;
-        frames:Object;
+    export class SpriteBatch extends DisplayObjectContainer {
+
+        constructor(texture?: Texture);
+
+        ready: boolean;
+        textureThing: Texture;
+
+        initWebGL(gl: WebGLRenderingContext): void;
+
+    }
+
+    export class SpriteSheetLoader implements Mixin {
+
         constructor(url: string, crossorigin?: boolean);
-        load();
+
+        baseUrl: string;
+        crossorigin: boolean;
+        frames: any;
+        texture: Texture;
+        url: string;
+
+        listeners(eventName: string): Function[];
+        emit(eventName: string, data?: any): boolean;
+        dispatchEvent(eventName: string, data?: any): boolean;
+        on(eventName: string, fn: Function): Function;
+        addEventListener(eventName: string, fn: Function): Function;
+        once(eventName: string, fn: Function): Function;
+        off(eventName: string, fn: Function): Function;
+        removeAllEventListeners(eventName: string): void;
+
+        load(): void;
+
     }
 
-    export class Stage extends DisplayObjectContainer
-    {
-        interactive:boolean;
-        interactionManager:InteractionManager;
-        constructor(backgroundColor: number, interactive?: boolean);
+    export class Stage extends DisplayObjectContainer {
+
+        constructor(backgroundColor: number);
+
+        interactionManager: InteractionManager;
+
         getMousePosition(): Point;
         setBackgroundColor(backgroundColor: number): void;
+        setInteractionDelegate(domElement: HTMLElement): void;
+
     }
 
-    export class Text extends Sprite
-    {
-        constructor(text: string, style: ITextStyle);
-        destroy(destroyTexture:boolean):void;
+    export class Strip extends DisplayObjectContainer {
+
+        static DrawModes: {
+
+            TRIANGLE_STRIP: number;
+            TRIANGLES: number;
+
+        }
+
+        constructor(texture: Texture);
+
+        blendMode: number;
+        colors: number[];
+        dirty: boolean;
+        indices: number[];
+        canvasPadding: number;
+        texture: Texture;
+        uvs: number[];
+        vertices: number[];
+
+        getBounds(matrix?: Matrix): Rectangle;
+
+    }
+
+    export class Text extends Sprite {
+
+        constructor(text: string, style?: TextStyle);
+
+        static fontPropertiesCanvas: any;
+        static fontPropertiesContext: any;
+        static fontPropertiesCache: any;
+
+        context: CanvasRenderingContext2D;
+        resolution: number;
+
+        destroy(destroyTexture: boolean): void;
+        setStyle(style: TextStyle): void;
         setText(text: string): void;
-        setStyle(style: ITextStyle): void;
+
     }
 
-    export class Texture extends EventTarget
-    {
+    export class Texture implements Mixin {
+
+        static emptyTexture: Texture;
+
+        static fromCanvas(canvas: HTMLCanvasElement, scaleMode?: scaleModes): Texture;
+        static fromFrame(frameId: string): Texture;
+        static fromImage(imageUrl: string, crossorigin?: boolean, scaleMode?: scaleModes): Texture;
+        static addTextureToCache(texture: Texture, id: string): void;
+        static removeTextureFromCache(id: string): Texture;
+
+        constructor(baseTexture: BaseTexture, frame?: Rectangle, crop?: Rectangle, trim?: Rectangle);
+
         baseTexture: BaseTexture;
+        crop: Rectangle;
         frame: Rectangle;
-        trim:Point;
-        render( displayObject:DisplayObject, position:Point, clear:boolean ):void;
-        constructor(baseTexture: BaseTexture, frame?: Rectangle);
-        destroy(destroyBase:boolean):void;
+        height: number;
+        noFrame: boolean;
+        requiresUpdate: boolean;
+        trim: Point;
+        width: number;
+        scope: any;
+        valid: boolean;
+
+        listeners(eventName: string): Function[];
+        emit(eventName: string, data?: any): boolean;
+        dispatchEvent(eventName: string, data?: any): boolean;
+        on(eventName: string, fn: Function): Function;
+        addEventListener(eventName: string, fn: Function): Function;
+        once(eventName: string, fn: Function): Function;
+        off(eventName: string, fn: Function): Function;
+        removeAllEventListeners(eventName: string): void;
+
+        destroy(destroyBase: boolean): void;
         setFrame(frame: Rectangle): void;
 
-        static addTextureToCache(texture: Texture, id: string): void;
-        static fromCanvas(canvas: HTMLCanvasElement): Texture;
-        static fromFrame(frameId: string): Texture;
-        static fromImage(imageUrl: string, crossorigin?: boolean): Texture;
-        static removeTextureFromCache(id: any): Texture;
     }
 
-    export class TilingSprite extends DisplayObjectContainer
-    {
-        width:number;
-        height:number;
-        texture:Texture;
+    export class TilingSprite extends Sprite {
+
+        constructor(texture: Texture, width: number, height: number);
+
+        blendMode: number;
+        texture: Texture;
+        tint: number;
         tilePosition: Point;
         tileScale: Point;
-        constructor(texture: Texture, width: number, height: number);
-        setTexture( texture: Texture ):void;
+        tileScaleOffset: Point;
+
+        destroy(): void;
+        generateTilingTexture(forcePowerOfTwo?: boolean): void;
+        setTexture(texture: Texture): void;
+
     }
 
-    export class WebGLBatch
-    {
-        constructor(webGLContext: WebGLRenderingContext);
-        clean():void;
-        restoreLostContext(gl:WebGLRenderingContext);
-        init(sprite: Sprite): void;
-        insertAfter(sprite: Sprite, previousSprite: Sprite): void;
-        insertBefore(sprite: Sprite, nextSprite: Sprite): void;
-        growBatch(): void;
-        merge(batch: WebGLBatch): void;
-        refresh(): void;
-        remove(sprite: Sprite): void;
-        render(): void;
-        split(sprite: Sprite): WebGLBatch;
-        update(): void;
+    export class TiltShiftFilter extends AbstractFilter {
+
+        blur: number;
+        gradientBlur: number;
+        start: number;
+        end: number;
+
     }
 
-    /* Determine type of Object */
-    export class WebGLRenderGroup
-    {
-        render(projection:Object):void;
+    export class TiltShiftXFilter extends AbstractFilter {
+
+        blur: number;
+        gradientBlur: number;
+        start: number;
+        end: number;
+
+        updateDelta(): void;
+
     }
 
-    export class WebGLRenderer implements IPixiRenderer
-    {
+    export class TiltShiftYFilter extends AbstractFilter {
+
+        blur: number;
+        gradientBlur: number;
+        start: number;
+        end: number;
+
+        updateDelta(): void;
+
+    }
+
+    export class TwistFilter extends AbstractFilter {
+
+        angle: number;
+        offset: Point;
+        radius: number;
+
+    }
+
+    export class VideoTexture extends BaseTexture {
+
+        static baseTextureFromVideo(video: HTMLVideoElement, scaleMode: number): BaseTexture;
+        static textureFromVideo(video: HTMLVideoElement, scaleMode: number): Texture;
+        static fromUrl(videoSrc: string, scaleMode: number): Texture;
+
+        autoUpdate: boolean;
+
+        destroy(): void;
+        updateBound(): void;
+        onPlayStart(): void;
+        onPlayStop(): void;
+        onCanPlay(): void;
+
+    }
+
+    export class WebGLBlendModeManager {
+
+        currentBlendMode: number;
+
+        destroy(): void;
+        setBlendMode(blendMode: number): boolean;
+        setContext(gl: WebGLRenderingContext): void;
+
+    }
+
+    export class WebGLFastSpriteBatch {
+
+        constructor(gl: CanvasRenderingContext2D);
+
+        currentBatchSize: number;
+        currentBaseTexture: BaseTexture;
+        currentBlendMode: number;
+        renderSession: RenderSession;
+        drawing: boolean;
+        indexBuffer: any;
+        indices: number[];
+        lastIndexCount: number;
+        matrix: Matrix;
+        maxSize: number;
+        shader: IPixiShader;
+        size: number;
+        vertexBuffer: any;
+        vertices: number[];
+        vertSize: number;
+
+        end(): void;
+        begin(spriteBatch: SpriteBatch, renderSession: RenderSession): void;
+        destroy(removeView?: boolean): void;
+        flush(): void;
+        render(spriteBatch: SpriteBatch): void;
+        renderSprite(sprite: Sprite): void;
+        setContext(gl: WebGLRenderingContext): void;
+        start(): void;
+        stop(): void;
+
+    }
+
+    export class WebGLFilterManager {
+
+        filterStack: AbstractFilter[];
+        transparent: boolean;
+        offsetX: number;
+        offsetY: number;
+
+        applyFilterPass(filter: AbstractFilter, filterArea: Texture, width: number, height: number): void;
+        begin(renderSession: RenderSession, buffer: ArrayBuffer): void;
+        destroy(): void;
+        initShaderBuffers(): void;
+        popFilter(): void;
+        pushFilter(filterBlock: FilterBlock): void;
+        setContext(gl: WebGLRenderingContext): void;
+
+    }
+
+    export class WebGLGraphics {
+
+        static graphicsDataPool: any[];
+
+        static renderGraphics(graphics: Graphics, renderRession: RenderSession): void;
+        static updateGraphics(graphics: Graphics, gl: WebGLRenderingContext): void;
+        static switchMode(webGL: WebGLRenderingContext, type: number): any; //WebGLData
+        static buildRectangle(graphicsData: GraphicsData, webGLData: any): void;
+        static buildRoundedRectangle(graphicsData: GraphicsData, webGLData: any): void;
+        static quadraticBezierCurve(fromX: number, fromY: number, cpX: number, cpY: number, toX: number, toY: number): number[];
+        static buildCircle(graphicsData: GraphicsData, webGLData: any): void;
+        static buildLine(graphicsData: GraphicsData, webGLData: any): void;
+        static buildComplexPoly(graphicsData: GraphicsData, webGLData: any): void;
+        static buildPoly(graphicsData: GraphicsData, webGLData: any): boolean;
+
+        reset(): void;
+        upload(): void;
+
+    }
+
+    export class WebGLGraphicsData {
+
+        constructor(gl: WebGLRenderingContext);
+
+        gl: WebGLRenderingContext;
+        glPoints: any[];
+        color: number[];
+        points: any[];
+        indices: any[];
+        buffer: WebGLBuffer;
+        indexBuffer: WebGLBuffer;
+        mode: number;
+        alpha: number;
+        dirty: boolean;
+
+        reset(): void;
+        upload(): void;
+
+    }
+
+    export class WebGLMaskManager {
+
+        destroy(): void;
+        popMask(renderSession: RenderSession): void;
+        pushMask(maskData: any[], renderSession: RenderSession): void;
+        setContext(gl: WebGLRenderingContext): void;
+
+    }
+
+    export class WebGLRenderer implements PixiRenderer {
+
+        static createWebGLTexture(texture: Texture, gl: WebGLRenderingContext): void;
+
+        constructor(width?: number, height?: number, options?: PixiRendererOptions);
+
+        autoResize: boolean;
+        clearBeforeRender: boolean;
+        contextLost: boolean;
+        contextLostBound: Function;
+        contextRestoreLost: boolean;
+        contextRestoredBound: Function;
+        height: number;
+        gl: WebGLRenderingContext;
+        offset: Point;
+        preserveDrawingBuffer: boolean;
+        projection: Point;
+        resolution: number;
+        renderSession: RenderSession;
+        shaderManager: WebGLShaderManager;
+        spriteBatch: WebGLSpriteBatch;
+        maskManager: WebGLMaskManager;
+        filterManager: WebGLFilterManager;
+        stencilManager: WebGLStencilManager;
+        blendModeManager: WebGLBlendModeManager;
+        transparent: boolean;
+        type: number;
         view: HTMLCanvasElement;
-        constructor(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean, antialias?:boolean );
+        width: number;
+
+        destroy(): void;
+        initContext(): void;
+        mapBlendModes(): void;
         render(stage: Stage): void;
+        renderDisplayObject(displayObject: DisplayObject, projection: Point, buffer: WebGLBuffer): void;
         resize(width: number, height: number): void;
+        updateTexture(texture: Texture): void;
+
+    }
+
+    export class WebGLShaderManager {
+
+        maxAttibs: number;
+        attribState: any[];
+        stack: any[];
+        tempAttribState: any[];
+
+        destroy(): void;
+        setAttribs(attribs: ShaderAttribute[]): void;
+        setContext(gl: WebGLRenderingContext): void;
+        setShader(shader: IPixiShader): boolean;
+
+    }
+
+    export class WebGLStencilManager {
+
+        stencilStack: any[];
+        reverse: boolean;
+        count: number;
+
+        bindGraphics(graphics: Graphics, webGLData: any[], renderSession: RenderSession): void;
+        destroy(): void;
+        popStencil(graphics: Graphics, webGLData: any[], renderSession: RenderSession): void;
+        pushStencil(graphics: Graphics, webGLData: any[], renderSession: RenderSession): void;
+        setContext(gl: WebGLRenderingContext): void;
+
+    }
+
+    export class WebGLSpriteBatch {
+
+        blendModes: number[];
+        colors: number[];
+        currentBatchSize: number;
+        currentBaseTexture: Texture;
+        defaultShader: AbstractFilter;
+        dirty: boolean;
+        drawing: boolean;
+        indices: number[];
+        lastIndexCount: number;
+        positions: number[];
+        textures: Texture[];
+        shaders: IPixiShader[];
+        size: number;
+        sprites: any[]; //todo Sprite[]?
+        vertices: number[];
+        vertSize: number;
+
+        begin(renderSession: RenderSession): void;
+        destroy(): void;
+        end(): void;
+        flush(shader?: IPixiShader): void;
+        render(sprite: Sprite): void;
+        renderBatch(texture: Texture, size: number, startIndex: number): void;
+        renderTilingSprite(sprite: TilingSprite): void;
+        setBlendMode(blendMode: blendModes): void;
+        setContext(gl: WebGLRenderingContext): void;
+        start(): void;
+        stop(): void;
+
+    }
+
+    export class RenderTexture extends Texture {
+
+        constructor(width?: number, height?: number, renderer?: PixiRenderer, scaleMode?: scaleModes, resolution?: number);
+
+        frame: Rectangle;
+        baseTexture: BaseTexture;
+        renderer: PixiRenderer;
+        resolution: number;
+        valid: boolean;
+
+        clear(): void;
+        getBase64(): string;
+        getCanvas(): HTMLCanvasElement;
+        getImage(): HTMLImageElement;
+        resize(width: number, height: number, updateBase: boolean): void;
+        render(displayObject: DisplayObject, position?: Point, clear?: boolean): void;
+
+    }
+
+    //SPINE
+
+    export class BoneData {
+
+        constructor(name: string, parent?: any);
+
+        name: string;
+        parent: any;
+        length: number;
+        x: number;
+        y: number;
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+
+    }
+
+    export class SlotData {
+
+        constructor(name: string, boneData: BoneData);
+
+        name: string;
+        boneData: BoneData;
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+        attachmentName: string;
+
+    }
+
+    export class Bone {
+
+        constructor(boneData: BoneData, parent?: any);
+
+        data: BoneData;
+        parent: any;
+        yDown: boolean;
+        x: number;
+        y: number;
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+        worldRotation: number;
+        worldScaleX: number;
+        worldScaleY: number;
+
+        updateWorldTransform(flipX: boolean, flip: boolean): void;
+        setToSetupPose(): void;
+
+    }
+
+    export class Slot {
+
+        constructor(slotData: SlotData, skeleton: Skeleton, bone: Bone);
+
+        data: SlotData;
+        skeleton: Skeleton;
+        bone: Bone;
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+        attachment: RegionAttachment;
+        setAttachment(attachment: RegionAttachment): void;
+        setAttachmentTime(time: number): void;
+        getAttachmentTime(): number;
+        setToSetupPose(): void;
+
+    }
+
+    export class Skin {
+
+        constructor(name: string);
+
+        name: string;
+        attachments: any;
+
+        addAttachment(slotIndex: number, name: string, attachment: RegionAttachment): void;
+        getAttachment(slotIndex: number, name: string): void;
+
+    }
+
+    export class Animation {
+
+        constructor(name: string, timelines: ISpineTimeline[], duration: number);
+
+        name: string;
+        timelines: ISpineTimeline[];
+        duration: number;
+        apply(skeleton: Skeleton, time: number, loop: boolean): void;
+        min(skeleton: Skeleton, time: number, loop: boolean, alpha: number): void;
+
+    }
+
+    export class Curves {
+
+        constructor(frameCount: number);
+
+        curves: number[];
+
+        setLinear(frameIndex: number): void;
+        setStepped(frameIndex: number): void;
+        setCurve(frameIndex: number, cx1: number, cy1: number, cx2: number, cy2: number): void;
+        getCurvePercent(frameIndex: number, percent: number): number;
+
+    }
+
+    export interface ISpineTimeline {
+
+        curves: Curves;
+        frames: number[];
+
+        getFrameCount(): number;
+        apply(skeleton: Skeleton, time: number, alpha: number): void;
+
+    }
+
+    export class RotateTimeline implements ISpineTimeline {
+
+        constructor(frameCount: number);
+
+        curves: Curves;
+        frames: number[];
+        boneIndex: number;
+
+        getFrameCount(): number;
+        setFrame(frameIndex: number, time: number, angle: number): void;
+        apply(skeleton: Skeleton, time: number, alpha: number): void;
+
+    }
+
+    export class TranslateTimeline implements ISpineTimeline {
+
+        constructor(frameCount: number);
+
+        curves: Curves;
+        frames: number[];
+        boneIndex: number;
+
+        getFrameCount(): number;
+        setFrame(frameIndex: number, time: number, x: number, y: number): void;
+        apply(skeleton: Skeleton, time: number, alpha: number): void;
+
+    }
+
+    export class ScaleTimeline implements ISpineTimeline {
+
+        constructor(frameCount: number);
+
+        curves: Curves;
+        frames: number[];
+        boneIndex: number;
+
+        getFrameCount(): number;
+        setFrame(frameIndex: number, time: number, x: number, y: number): void;
+        apply(skeleton: Skeleton, time: number, alpha: number): void;
+
+    }
+
+    export class ColorTimeline implements ISpineTimeline {
+
+        constructor(frameCount: number);
+
+        curves: Curves;
+        frames: number[];
+        boneIndex: number;
+
+        getFrameCount(): number;
+        setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number): void;
+        apply(skeleton: Skeleton, time: number, alpha: number): void;
+
+    }
+
+    export class AttachmentTimeline implements ISpineTimeline {
+
+        constructor(frameCount: number);
+
+        curves: Curves;
+        frames: number[];
+        attachmentNames: string[];
+        slotIndex: number;
+
+        getFrameCount(): number;
+        setFrame(frameIndex: number, time: number, attachmentName: string): void;
+        apply(skeleton: Skeleton, time: number, alpha: number): void;
+
+    }
+
+    export class SkeletonData {
+
+        bones: Bone[];
+        slots: Slot[];
+        skins: Skin[];
+        animations: Animation[];
+        defaultSkin: Skin;
+
+        findBone(boneName: string): Bone;
+        findBoneIndex(boneName: string): number;
+        findSlot(slotName: string): Slot;
+        findSlotIndex(slotName: string): number;
+        findSkin(skinName: string): Skin;
+        findAnimation(animationName: string): Animation;
+
+    }
+
+    export class Skeleton {
+
+        constructor(skeletonData: SkeletonData);
+
+        data: SkeletonData;
+        bones: Bone[];
+        slots: Slot[];
+        drawOrder: any[];
+        x: number;
+        y: number;
+        skin: Skin;
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+        time: number;
+        flipX: boolean;
+        flipY: boolean;
+
+        updateWorldTransform(): void;
+        setToSetupPose(): void;
+        setBonesToSetupPose(): void;
+        setSlotsToSetupPose(): void;
+        getRootBone(): Bone;
+        findBone(boneName: string): Bone;
+        fineBoneIndex(boneName: string): number;
+        findSlot(slotName: string): Slot;
+        findSlotIndex(slotName: string): number;
+        setSkinByName(skinName: string): void;
+        setSkin(newSkin: Skin): void;
+        getAttachmentBySlotName(slotName: string, attachmentName: string): RegionAttachment;
+        getAttachmentBySlotIndex(slotIndex: number, attachmentName: string): RegionAttachment;
+        setAttachment(slotName: string, attachmentName: string): void;
+        update(data: number): void;
+
+    }
+
+    export class RegionAttachment {
+
+        offset: number[];
+        uvs: number[];
+        x: number;
+        y: number;
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+        width: number;
+        height: number;
+        rendererObject: any;
+        regionOffsetX: number;
+        regionOffsetY: number;
+        regionWidth: number;
+        regionHeight: number;
+        regionOriginalWidth: number;
+        regionOriginalHeight: number;
+
+        setUVs(u: number, v: number, u2: number, v2: number, rotate: number): void;
+        updateOffset(): void;
+        computeVertices(x: number, y: number, bone: Bone, vertices: number[]): void;
+
+    }
+
+    export class AnimationStateData {
+
+        constructor(skeletonData: SkeletonData);
+
+        skeletonData: SkeletonData;
+        animationToMixTime: any;
+        defaultMix: number;
+
+        setMixByName(fromName: string, toName: string, duration: number): void;
+        setMix(from: string, to: string): number;
+
+    }
+
+    export class AnimationState {
+
+        constructor(stateData: any);
+
+        animationSpeed: number;
+        current: any;
+        previous: any;
+        currentTime: number;
+        previousTime: number;
+        currentLoop: boolean;
+        previousLoop: boolean;
+        mixTime: number;
+        mixDuration: number;
+        queue: Animation[];
+
+        update(delta: number): void;
+        apply(skeleton: any): void;
+        clearAnimation(): void;
+        setAnimation(animation: any, loop: boolean): void;
+        setAnimationByName(animationName: string, loop: boolean): void;
+        addAnimationByName(animationName: string, loop: boolean, delay: number): void;
+        addAnimation(animation: any, loop: boolean, delay: number): void;
+        isComplete(): number;
+
+    }
+
+    export class SkeletonJson {
+
+        constructor(attachmentLoader: AtlasAttachmentLoader);
+
+        attachmentLoader: AtlasAttachmentLoader;
+        scale: number;
+
+        readSkeletonData(root: any): SkeletonData;
+        readAttachment(skin: Skin, name: string, map: any): RegionAttachment;
+        readAnimation(name: string, map: any, skeletonData: SkeletonData): void;
+        readCurve(timeline: ISpineTimeline, frameIndex: number, valueMap: any): void;
+        toColor(hexString: string, colorIndex: number): number;
+
+    }
+
+    export class Atlas {
+
+        static FORMAT: {
+
+            alpha: number;
+            intensity: number;
+            luminanceAlpha: number;
+            rgb565: number;
+            rgba4444: number;
+            rgb888: number;
+            rgba8888: number;
+
+        }
+
+        static TextureFilter: {
+
+            nearest: number;
+            linear: number;
+            mipMap: number;
+            mipMapNearestNearest: number;
+            mipMapLinearNearest: number;
+            mipMapNearestLinear: number;
+            mipMapLinearLinear: number;
+
+        }
+
+        static textureWrap: {
+
+            mirroredRepeat: number;
+            clampToEdge: number;
+            repeat: number;
+
+        }
+
+        constructor(atlasText: string, textureLoader: AtlasLoader);
+
+        textureLoader: AtlasLoader;
+        pages: AtlasPage[];
+        regions: AtlasRegion[];
+
+        findRegion(name: string): AtlasRegion;
+        dispose(): void;
+        updateUVs(page: AtlasPage): void;
+
+    }
+
+    export class AtlasPage {
+
+        name: string;
+        format: number;
+        minFilter: number;
+        magFilter: number;
+        uWrap: number;
+        vWrap: number;
+        rendererObject: any;
+        width: number;
+        height: number;
+
+    }
+
+    export class AtlasRegion {
+
+        page: AtlasPage;
+        name: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        u: number;
+        v: number;
+        u2: number;
+        v2: number;
+        offsetX: number;
+        offsetY: number;
+        originalWidth: number;
+        originalHeight: number;
+        index: number;
+        rotate: boolean;
+        splits: any[];
+        pads: any[];
+
+    }
+
+    export class AtlasReader {
+
+        constructor(text: string);
+
+        lines: string[];
+        index: number;
+
+        trim(value: string): string;
+        readLine(): string;
+        readValue(): string;
+        readTuple(tuple: number): number;
+
+    }
+
+    export class AtlasAttachmentLoader {
+
+        constructor(atlas: Atlas);
+
+        atlas: Atlas;
+
+        newAttachment(skin: Skin, type: number, name: string): RegionAttachment;
+
+    }
+
+    export class Spine extends DisplayObjectContainer {
+
+        constructor(url: string);
+
+        autoUpdate: boolean;
+        spineData: any;
+        skeleton: Skeleton;
+        stateData: AnimationStateData;
+        state: AnimationState;
+        slotContainers: DisplayObjectContainer[];
+
+        createSprite(slot: Slot, descriptor: { name: string }): Sprite[];
+        update(dt: number): void;
+
     }
 
 }
 
-declare function requestAnimFrame( animate: PIXI.IBasicCallback );
-
-
-declare module PIXI.PolyK
-{
-    export function Triangulate( p:number[]):number[];
-}
-
-
+declare function requestAnimFrame(callback: Function): void;
 
+declare module PIXI.PolyK {
+    export function Triangulate(p: number[]): number[];
+}
\ No newline at end of file