diff --git a/createjs-lib/createjs-lib.d.ts b/createjs-lib/createjs-lib.d.ts
index a61679aa7a..cfd77e20ac 100644
--- a/createjs-lib/createjs-lib.d.ts
+++ b/createjs-lib/createjs-lib.d.ts
@@ -56,6 +56,7 @@ declare module createjs {
         clone(): Event;
         preventDefault(): void;
         remove(): void;
+        set(props: Object): Event;
         stopImmediatePropagation(): void;
         stopPropagation(): void;
         toString(): string;
@@ -93,7 +94,9 @@ declare module createjs {
         willTrigger(type: string): boolean;
     }
 
+    export function extend(subclass: () => any, superclass: () => any): () => any;     // returns the subclass prototype
     export function indexOf(array: any[], searchElement: Object): number;
+    export function promote(subclass: () => any, prefix: string): () => any;
 
     export function proxy(method: (eventObj: Object) => boolean, scope: Object, ...arg: any[]): (eventObj: Object) => any;
     export function proxy(method: (eventObj: Object) => void, scope: Object, ...arg: any[]): (eventObj: Object) => any;
diff --git a/easeljs/easeljs.d.ts b/easeljs/easeljs.d.ts
index 08378828a2..b2beb8b8b7 100644
--- a/easeljs/easeljs.d.ts
+++ b/easeljs/easeljs.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for EaselJS 0.7.1
+// Type definitions for EaselJS 0.8.0
 // Project: http://www.createjs.com/#!/EaselJS
 // Definitions by: Pedro Ferreira <https://bitbucket.org/drk4>, Chris Smith <https://github.com/evilangelist>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -59,25 +59,18 @@ declare module createjs {
         setTransform(x?: number, y?: number, scaleX?: number, scaleY?: number, rotation?: number, skewX?: number, skewY?: number, regX?: number, regY?: number): Bitmap;
     }
     
-    /**
-     * @deprecated renamed to Sprite, here for backwards compatibility
-     */
-    export class BitmapAnimation extends Sprite {
-    }
-    
+
     export class BitmapText extends DisplayObject {
         constructor(text?:string, spriteSheet?:SpriteSheet);
 
+        static maxPoolSize: number;
+
         // properties
         letterSpacing: number;
         lineHeight: number;
         spaceWidth: number;
         spriteSheet: SpriteSheet;
         text: string;
-
-        // methods
-        set(props: Object): BitmapText;
-        setTransform(x?: number, y?: number, scaleX?: number, scaleY?: number, rotation?: number, skewX?: number, skewY?: number, regX?: number, regY?: number): BitmapText;
     }
     
     export class BlurFilter extends Filter {
@@ -102,6 +95,7 @@ declare module createjs {
         overLabel: any; // String or Number
         play: boolean;
         target: DisplayObject; // MovieClip or Sprite
+        enabled: boolean;
 
         // methods
         setEnabled(value: boolean): void;
@@ -137,9 +131,10 @@ declare module createjs {
         clone(): ColorMatrix;
         concat(...matrix: number[]): ColorMatrix;
         concat(matrix: ColorMatrix): ColorMatrix;
-        copyMatrix(...matrix: number[]): ColorMatrix;
-        copyMatrix(matrix: ColorMatrix): ColorMatrix;
+        copy(...matrix: number[]): ColorMatrix;
+        copy(matrix: ColorMatrix): ColorMatrix;
         reset(): ColorMatrix;
+        setColor( brightness: number, contrast: number, saturation: number, hue: number ): ColorMatrix;
         toArray(): number[];
         toString(): string;
     }
@@ -148,22 +143,21 @@ declare module createjs {
         constructor(matrix: number[]);
         constructor(matrix: ColorMatrix);
 
+        // properties
+        matrix: ColorMatrix;    // or array
+
         // methods
         clone(): ColorMatrixFilter;
     }
     
-    export class Command {
-        // methods
-        constructor(f: any, params: any, path?: any);
-        exec(scope: any): void;
-    }
-    
+
     export class Container extends DisplayObject {
         constructor();
 
         // properties
         children: DisplayObject[];
         mouseChildren: boolean;
+        numChildren: number;
         tickChildren: boolean;
 
         // methods
@@ -175,9 +169,12 @@ declare module createjs {
         getChildAt(index: number): DisplayObject;
         getChildByName(name: string): DisplayObject;
         getChildIndex(child: DisplayObject): number;
+        /**
+         * @deprecated - use numChildren property instead.
+         */
         getNumChildren(): number;
-        getObjectsUnderPoint(x: number, y: number): DisplayObject[];
-        getObjectUnderPoint(x: number, y: number): DisplayObject;
+        getObjectsUnderPoint(x: number, y: number, mode: number): DisplayObject[];
+        getObjectUnderPoint(x: number, y: number, mode: number): DisplayObject;
         removeAllChildren(): void;
         removeChild(...child: DisplayObject[]): boolean;
         removeChildAt(...index: number[]): boolean;
@@ -217,8 +214,10 @@ declare module createjs {
          * @deprecated
          */
         snapToPixel: boolean;
+        stage: Stage;
         static suppressCrossDomainErrors: boolean;
         tickEnabled: boolean;
+        transformMatrix: Matrix2D;
         visible: boolean;
         x: number;
         y: number;
@@ -229,15 +228,19 @@ declare module createjs {
         draw(ctx: CanvasRenderingContext2D, ignoreCache?: boolean): boolean;
         getBounds(): Rectangle;
         getCacheDataURL(): string;
+        getConcatenatedDisplayProps(props?: DisplayProps): DisplayProps;
         getConcatenatedMatrix(mtx?: Matrix2D): Matrix2D;
         getMatrix(matrix?: Matrix2D): Matrix2D;
+        /**
+         * @deprecated
+         */
         getStage(): Stage;
         getTransformedBounds(): Rectangle;
-        globalToLocal(x: number, y: number): Point;
+        globalToLocal(x: number, y: number, pt?: Object): Point;    // 'pt' is Point or Object
         hitTest(x: number, y: number): boolean;
         isVisible(): boolean;
-        localToGlobal(x: number, y: number): Point;
-        localToLocal(x: number, y: number, target: DisplayObject): Point;
+        localToGlobal(x: number, y: number, pt?: Object): Point;    // 'pt' is Point or Object
+        localToLocal(x: number, y: number, target: DisplayObject, pt?: Object): Point;  // 'pt' is Point or Object
         set(props: Object): DisplayObject;
         setBounds(x: number, y: number, width: number, height: number): void;
         setTransform(x?: number, y?: number, scaleX?: number, scaleY?: number, rotation?: number, skewX?: number, skewY?: number, regX?: number, regY?: number): DisplayObject;
@@ -247,6 +250,25 @@ declare module createjs {
         
     }
 
+    export class DisplayProps {
+        constructor(visible?: number, alpha?: number, shadow?: number, compositeOperation?: number, matrix?: number);
+
+        // properties
+        alpha: number;
+        compositeOperation: string;
+        matrix: Matrix2D;
+        shadow: Shadow;
+        visible: boolean;
+
+        // methods
+        append(visible: boolean, alpha: number, shadow: Shadow, compositeOperation: string, matrix?: Matrix2D): DisplayProps;
+        clone(): DisplayProps;
+        identity(): DisplayProps;
+        prepend(visible: boolean, alpha: number, shadow: Shadow, compositeOperation: string, matrix?: Matrix2D): DisplayProps;
+        setValues(visible?: boolean, alpha?: number, shadow?: number, compositeOperation?: number, matrix?: number): DisplayProps;
+    }
+
+
     export class DOMElement extends DisplayObject {
         constructor(htmlElement: HTMLElement);
 
@@ -281,11 +303,14 @@ declare module createjs {
 
         // properties
         static BASE_64: Object;
-        static Command: any;
+        static beginCmd: Graphics.BeginPath;
+        command: Object;
+        instructions: Object[]; // array of graphics command objects (Graphics.Fill, etc)
         static STROKE_CAPS_MAP: string[];
         static STROKE_JOINTS_MAP: string[];
 
         // methods
+        append(command: Object, clean?: boolean): Graphics;
         arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise: boolean): Graphics;
         arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): Graphics;
         beginBitmapFill(image: Object, repetition?: string, matrix?: Matrix2D): Graphics;
@@ -300,7 +325,7 @@ declare module createjs {
         clear(): Graphics;
         clone(): Graphics;
         closePath(): Graphics;
-        curveTo (cpx: number, cpy: number, x: number, y: number): Graphics;
+        curveTo(cpx: number, cpy: number, x: number, y: number): Graphics;
         decodePath(str: string): Graphics;
         draw(ctx: CanvasRenderingContext2D): void;
         drawAsPath(ctx: CanvasRenderingContext2D): void;
@@ -313,8 +338,12 @@ declare module createjs {
         endFill(): Graphics;
         endStroke(): Graphics;
         static getHSL(hue: number, saturation: number, lightness: number, alpha?: number): string;
+        /**
+         * @deprecated - use the instructions property instead
+         */
+        getInstructions(): Object[];
         static getRGB(r: number, g: number, b: number, alpha?: number): string;
-        inject(callback: (data: any) => any,  data: any): Graphics;
+        inject(callback: (data: any) => any,  data: any): Graphics; // deprecated
         isEmpty(): boolean;
         lineTo(x: number, y: number): Graphics;
         moveTo(x: number, y: number): Graphics;
@@ -324,7 +353,9 @@ declare module createjs {
         setStrokeStyle(thickness: number, caps?: number, joints?: string, miterLimit?: number, ignoreScale?: boolean): Graphics;
         setStrokeStyle(thickness: number, caps?: string, joints?: number, miterLimit?: number, ignoreScale?: boolean): Graphics;
         setStrokeStyle(thickness: number, caps?: number, joints?: number, miterLimit?: number, ignoreScale?: boolean): Graphics;
+        store(): Graphics;
         toString(): string;
+        unstore(): Graphics;
 
 
         // tiny API - short forms of methods above
@@ -360,42 +391,207 @@ declare module createjs {
         ss(thickness: number, caps?: number, joints?: number, miterLimit?: number, ignoreScale?: boolean): Graphics;
     }
 
+
+    module Graphics
+        {
+        export class Arc
+            {
+            constructor(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise: number);
+
+            // properties
+            anticlockwise: number;
+            endAngle: number;
+            radius: number;
+            startAngle: number;
+            x: number;
+            y: number;
+            }
+
+        export class ArcTo
+            {
+            constructor(x1: number, y1: number, x2: number, y2: number, radius: number);
+
+            // properties
+            x1: number;
+            y1: number;
+            x2: number;
+            y2: number;
+            radius: number;
+            }
+
+        export class BeginPath
+            {
+
+            }
+
+        export class BezierCurveTo
+            {
+            constructor(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number);
+
+            // properties
+            cp1x: number;
+            cp1y: number;
+            cp2x: number;
+            cp2y: number;
+            x: number;
+            y: number;
+            }
+
+        export class Circle
+            {
+            constructor(x: number, y: number, radius: number);
+
+            // properties
+            x: number;
+            y: number;
+            radius: number;
+            }
+
+        export class ClosePath
+            {
+
+            }
+
+        export class Fill
+            {
+            constructor(style: Object, matrix?: Matrix2D);
+
+            // properties
+            style: Object;
+            matrix: Matrix2D;
+
+            // methods
+            bitmap(image: HTMLImageElement, repetition?: string): Fill;
+            linearGradient(colors: number[], ratios: number[], x0: number, y0: number, x1: number, y1: number): Fill;
+            radialGradient(colors: number[], ratios: number[], x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): Fill;
+            }
+
+        export class LineTo
+            {
+            constructor(x: number, y: number);
+
+            // properties
+            x: number;
+            y: number;
+            }
+
+        export class MoveTo
+            {
+            constructor(x: number, y: number);
+
+            x: number;
+            y: number;
+            }
+
+        export class PolyStar
+            {
+            constructor(x: number, y: number, radius: number, sides: number, pointSize: number, angle: number);
+
+            // properties
+            angle: number;
+            pointSize: number;
+            radius: number;
+            sides: number;
+            x: number;
+            y: number;
+            }
+
+        export class QuadraticCurveTo
+            {
+            constructor(cpx: number, cpy: number, x: number, y: number);
+
+            // properties
+            cpx: number;
+            cpy: number;
+            x: number;
+            y: number;
+            }
+
+        export class Rect
+            {
+            constructor(x: number, y: number, w: number, h: number);
+
+            // properties
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            }
+
+        export class RoundRect
+            {
+            constructor(x: number, y: number, w: number, h: number, radiusTL: number, radiusTR: number, radiusBR: number, radiusBL: number);
+
+            // properties
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            radiusTL: number;
+            radiusTR: number;
+            radiusBR: number;
+            radiusBL: number;
+            }
+
+        export class Stroke
+            {
+            constructor(style: Object, ignoreScale: boolean);
+
+            // properties
+            style: Object;
+            ignoreScale: boolean;
+
+            // methods
+            bitmap(image: HTMLImageElement, repetition?: string): Stroke;
+            linearGradient(colors: number[], ratios: number[], x0: number, y0: number, x1: number, y1: number): Stroke;
+            radialGradient(colors: number[], ratios: number[], x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): Stroke;
+            }
+
+        export class StrokeStyle
+            {
+            constructor(width: number, caps: string, joints: number, miterLimit: number);
+
+            // properties
+            caps: string;
+            joints: string;
+            miterLimit: number;
+            width: number;
+            }
+        }
+
+
+
     export class Matrix2D {
         constructor(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number);
 
         // properties
         a: number;
-        alpha: number;
         b: number;
         c: number;
-        compositeOperation: string;
         d: number;
         static DEG_TO_RAD: number;
         static identity: Matrix2D;
-        shadow: Shadow;
         tx: number;
         ty: number;
 
         // methods
         append(a: number, b: number, c: number, d: number, tx: number, ty: number): Matrix2D;
         appendMatrix(matrix: Matrix2D): Matrix2D;
-        appendProperties(alpha: number, shadow: Shadow, compositeOperation: string): Matrix2D;
         appendTransform(x: number, y: number, scaleX: number, scaleY: number, rotation: number, skewX: number, skewY: number, regX?: number, regY?: number): Matrix2D;
         clone(): Matrix2D;
         copy(matrix: Matrix2D): Matrix2D;
         decompose(): {x: number; y: number; scaleX: number; scaleY: number; rotation: number; skewX: number; skewY: number};
         decompose(target: Object): Matrix2D;
+        equals(matrix: Matrix2D): boolean;
         identity(): Matrix2D;
-        initialize(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number): Matrix2D;
         invert(): Matrix2D;
         isIdentity(): boolean;
         prepend(a: number, b: number, c: number, d: number, tx: number, ty: number): Matrix2D;
         prependMatrix(matrix: Matrix2D): Matrix2D;
-        prependProperties(alpha: number, shadow: Shadow, compositeOperation: string): Matrix2D;
         prependTransform(x: number, y: number, scaleX: number, scaleY: number, rotation: number, skewX: number, skewY: number, regX?: number, regY?: number): Matrix2D;
-        reinitialize(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number, alpha?: number, shadow?: Shadow, compositeOperation?: string): Matrix2D;
         rotate(angle: number): Matrix2D;
         scale(x: number, y: number): Matrix2D;
+        setValues(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number): Matrix2D;
         skew(skewX: number, skewY: number): Matrix2D;
         toString(): string;
         transformPoint(x: number, y: number, pt?: Point): Point;
@@ -408,6 +604,7 @@ declare module createjs {
         constructor(type: string, bubbles: boolean, cancelable: boolean, stageX: number, stageY: number, nativeEvent: NativeMouseEvent, pointerID: number, primary: boolean, rawX: number, rawY: number);
         
         // properties
+        isTouch: boolean;
         localX: number;
         localY: number;
         nativeEvent: NativeMouseEvent;
@@ -458,8 +655,11 @@ declare module createjs {
         autoReset: boolean;
         static buildDate: string;
         currentFrame: number;
+        currentLabel: string;
         frameBounds: Rectangle[];
+        framerate: number;
         static INDEPENDENT: string;
+        labels: Object[];
         loop: boolean;
         mode: string;
         paused: boolean;
@@ -470,8 +670,15 @@ declare module createjs {
         static version: string;
 
         // methods
+        advance(time?: number): void;
         clone(): MovieClip; // not supported
-        getCurrentLabel(): string;
+        /**
+         * @deprecated - use 'currentLabel' property instead
+         */
+        getCurrentLabel(): string;  // deprecated
+        /**
+         * @deprecated - use 'labels' property instead
+         */
         getLabels(): Object[];
         gotoAndPlay(positionOrLabel: string): void;
         gotoAndPlay(positionOrLabel: number): void;
@@ -498,7 +705,7 @@ declare module createjs {
         // methods
         clone(): Point;
         copy(point: Point): Point;
-        initialize (x?: number, y?: number): Point;
+        setValues(x?: number, y?: number): Point;
         toString(): string;
     }
 
@@ -513,9 +720,15 @@ declare module createjs {
 
         // methods
         clone(): Rectangle;
+        contains(x: number, y: number, width?: number, height?: number): boolean;
         copy(rectangle: Rectangle): Rectangle;
-        initialize(x?: number, y?: number, width?: number, height?: number): Rectangle;
+        extend(x: number, y: number, width?: number, height?: number): Rectangle;
+        intersection(rect: Rectangle): Rectangle;
+        intersects(rect: Rectangle): boolean;
+        isEmpty(): boolean;
+        setValues(x?: number, y?: number, width?: number, height?: number): Rectangle;
         toString(): string;
+        union(rect: Rectangle): Rectangle;
     }
 
 
@@ -579,6 +792,13 @@ declare module createjs {
         
     }
 
+    export class SpriteContainer extends Container
+        {
+        constructor(spriteSheet?: SpriteSheet);
+
+        spriteSheet: SpriteSheet;
+        }
+
     // what is returned from SpriteSheet.getAnimation(string)
     interface SpriteSheetAnimation {
         frames: number[];
@@ -597,12 +817,16 @@ declare module createjs {
         constructor(data: Object);
 
         // properties
+        animations: string[];
         complete: boolean;
         framerate: number;
         
         // methods
         clone(): SpriteSheet;
         getAnimation(name: string): SpriteSheetAnimation;
+        /**
+         * @deprecated - use the 'animations' property instead
+         */
         getAnimations(): string[];
         getFrame(frameIndex: number): SpriteSheetFrame;
         getFrameBounds(frameIndex: number, rectangle?: Rectangle): Rectangle;
@@ -624,14 +848,12 @@ declare module createjs {
 
         // methods
         addAnimation(name: string, frames: number[], next?: string, frequency?: number): void;
-        addFrame(source: DisplayObject, sourceRect?: Rectangle, scale?: number, setupFunction?: () => any, setupParams?: any[], setupScope?: Object): number;
-        addMovieClip(source: MovieClip, sourceRect?: Rectangle, scale?: number): void;
+        addFrame(source: DisplayObject, sourceRect?: Rectangle, scale?: number, setupFunction?: () => any, setupData?: Object): number;
+        addMovieClip(source: MovieClip, sourceRect?: Rectangle, scale?: number, setupFunction?: () => any, setupData?: Object, labelFunction?: () => any): void;
         build(): SpriteSheet;
         buildAsync(timeSlice?: number): void;
         clone(): void; // throw error
         stopAsync(): void;
-
-
     }
 
     export class SpriteSheetUtils {
@@ -647,6 +869,25 @@ declare module createjs {
         static mergeAlpha(rgbImage: HTMLImageElement, alphaImage: HTMLImageElement, canvas?: HTMLCanvasElement): HTMLCanvasElement; // deprecated
     }
 
+    export class SpriteStage extends Stage
+        {
+        constructor(canvas: HTMLCanvasElement, preserveDrawingBuffer?: boolean, antialias?: boolean);
+        constructor(canvas: string, preserveDrawingBuffer?: boolean, antialias?: boolean);
+
+        // properties
+        static INDICES_PER_BOX: number;
+        isWebGL: boolean;
+        static MAX_BOXES_POINTS_INCREMENT: number;
+        static MAX_INDEX_SIZE: number;
+        static NUM_VERTEX_PROPERTIES: number;
+        static NUM_VERTEX_PROPERTIES_PER_BOX: number;
+        static POINTS_PER_BOX: number;
+
+        // methods
+        clearImageTexture(image: Object): void;
+        updateViewport(width: number, height: number): void;
+        }
+
     export class Stage extends Container {
         constructor(canvas: HTMLCanvasElement);
         constructor(canvas: string);
@@ -655,6 +896,7 @@ declare module createjs {
         // properties
         autoClear: boolean;
         canvas: any; // HTMLCanvasElement or Object
+        drawRect: Rectangle;
         handleEvent: Function;
         mouseInBounds: boolean;
         mouseMoveOutside: boolean;
@@ -664,6 +906,7 @@ declare module createjs {
         /**
          * @deprecated
          */
+        preventSelection: boolean;
         snapToPixelEnabled: boolean;  // deprecated
         tickOnUpdate: boolean;
         
@@ -672,6 +915,7 @@ declare module createjs {
         clone(): Stage;
         enableDOMEvents(enable?: boolean): void;
         enableMouseOver(frequency?: number): void;
+        tick(props?: Object): void;
         toDataURL(backgroundColor: string, mimeType: string): string;
         update(...arg: any[]): void;
         
@@ -697,13 +941,17 @@ declare module createjs {
         getMeasuredHeight(): number;
         getMeasuredLineHeight(): number;
         getMeasuredWidth(): number;
+        getMetrics(): Object;
         set(props: Object): Text;
         setTransform(x?: number, y?: number, scaleX?: number, scaleY?: number, rotation?: number, skewX?: number, skewY?: number, regX?: number, regY?: number): Text;
     }
 
     export class Ticker {
         // properties
+        static framerate: number;
+        static interval: number;
         static maxDelta: number;
+        static paused: number;
         static RAF: string;
         static RAF_SYNCHED: string;
         static TIMEOUT: string;
@@ -715,17 +963,35 @@ declare module createjs {
 
         // methods
         static getEventTime(runTime?: boolean): number;
+        /**
+         * @deprecated - use the 'framerate' property instead
+         */
         static getFPS(): number;
+        /**
+         * @deprecated - use the 'interval' property instead
+         */
         static getInterval(): number;
         static getMeasuredFPS(ticks?: number): number;
         static getMeasuredTickTime(ticks?: number): number;
+        /**
+         * @deprecated - use the 'paused' property instead
+         */
         static getPaused(): boolean;
         static getTicks(pauseable?: boolean): number;
         static getTime(runTime?: boolean): number;
         static init(): void;
         static reset(): void;
+        /**
+         * @deprecated - use the 'framerate' property instead
+         */
         static setFPS(value: number): void;
+        /**
+         * @deprecated - use the 'interval' property instead
+         */
         static setInterval(interval: number): void;
+        /**
+         * @deprecated - use the 'paused' property instead
+         */
         static setPaused(value: boolean): void;
 
         // EventDispatcher mixins
diff --git a/preloadjs/preloadjs.d.ts b/preloadjs/preloadjs.d.ts
index 0a4a4db85d..12545369cd 100644
--- a/preloadjs/preloadjs.d.ts
+++ b/preloadjs/preloadjs.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for PreloadJS 0.4.1
+// Type definitions for PreloadJS 0.6.0
 // Project: http://www.createjs.com/#!/PreloadJS
 // Definitions by: Pedro Ferreira <https://bitbucket.org/drk4>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -16,88 +16,277 @@
 
 declare module createjs {
     export class AbstractLoader extends EventDispatcher {
-        // properties
-        canceled: boolean;
-        loaded: boolean;
-        progress: number;
-        
-        // methods
-        buildPath(src: string, data?: Object): string;
-        close(): void;
-        load(): void;
-    }
-    
-    export class LoadQueue extends AbstractLoader {
-        constructor(useXHR?: boolean, basePath?: string, crossOrigin?: string);
-        constructor(useXHR?: boolean, basePath?: string, crossOrigin?: boolean);
-
         // properties
         static BINARY: string;
+        canceled: boolean;
         static CSS: string;
+        GET: string;
         static IMAGE: string;
         static JAVASCRIPT: string;
         static JSON: string;
         static JSONP: string;
-        static loadTimeout: number;
-        maintainScriptOrder: boolean;
+        loaded: boolean;
         static MANIFEST: string;
-        next: LoadQueue;
+        POST: string;
+        progress: number;
+        resultFormatter: () => any;
         static SOUND: string;
-        stopOnError: boolean;
+        static SPRITESHEET: string;
         static SVG: string;
         static TEXT: string;
-        useXHR: boolean;
+        type: string;
+        static VIDEO: string;
         static XML: string;
-        
+
         // methods
-        getItem(value: string): Object;
-        getResult(value: string, rawResult?: boolean): Object;
-        installPlugin(plugin: any): void;
+        cancel(): void;
+        destroy(): void;
+        getItem(value?: string): Object;
+        getLoadedItems(): Object[];
+        getResult(value?: any, rawResult?: boolean): Object;
+        getTag(): Object;
+        load(): void;
+        setTag(tag: Object): void;
+        toString(): string;
+    }
+
+    export class AbstractMediaLoader
+        {
+        constructor(loadItem: Object, preferXHR: boolean, type: string);
+        }
+
+    export class AbstractRequest
+        {
+        constructor(item: LoadItem);
+
+        cancel(): void;
+        destroy(): void;
+        load(): void;
+        }
+
+    export class BinaryLoader
+        {
+        constructor(loadItem: Object);
+
+        // methods
+        static canLoadItem(item: Object): boolean;
+        }
+
+    export class CSSLoader
+        {
+        constructor(loadItem: Object, preferXHR: boolean);
+
+        // methods
+        canLoadItem(item: Object): boolean;
+        }
+
+    export module DataUtils
+        {
+        export function parseJSON(value: string): Object;
+        export function parseXML(text: string, type: string): XMLDocument;
+        }
+
+    export class ErrorEvent
+        {
+        constructor(title?: string, message?: string, data?: Object);
+
+        // properties
+        data: Object;
+        message: string;
+        title: string;
+        }
+
+    export class ImageLoader
+        {
+        constructor(loadItem: Object, preferXHR: boolean);
+
+        static canLoadItem(item: Object): boolean;
+        }
+
+    export class JavaScriptLoader
+        {
+        constructor(loadItem: Object, preferXHR: boolean);
+
+        static canLoadItem(item: Object): boolean;
+        }
+
+    export class JSONLoader
+        {
+        constructor(loadItem: Object);
+
+        static canLoadItem(item: Object): boolean;
+        }
+
+    export class JSONPLoader
+        {
+        constructor(loadItem: Object);
+
+        static canLoadItem(item: Object): boolean;
+        }
+
+    export class LoadItem
+        {
+        // properties
+        callback: string;
+        crossOrigin: boolean;
+        data: Object;
+        headers: Object;
+        id: string;
+        loadTimeout: number;
+        maintainOrder: boolean;
+        method: string;
+        mimeType: string;
+        src: string;
+        type: string;
+        values: Object;
+        withCredentials: boolean;
+
+        // methods
+        static create(value: Object): Object;   // 'value' is a LoadItem, string or Object. Returns Object or LoadItem
+        set(props: Object): LoadItem;
+        }
+    
+    export class LoadQueue extends AbstractLoader
+        {
+        constructor(preferXHR?: boolean, basePath?: string, crossOrigin?: string);
+        constructor(preferXHR?: boolean, basePath?: string, crossOrigin?: boolean);
+
+        // properties
+        maintainScriptOrder: boolean;
+        next: LoadQueue;
+        stopOnError: boolean;
+
+        // methods
+        close(): void;
+        getItems(loaded: boolean): Object[];
+        installPlugin(plugin: () => any): void;
         loadFile(file: Object, loadNow?: boolean, basePath?: string): void;
         loadFile(file: string, loadNow?: boolean, basePath?: string): void;
         loadManifest(manifest: Object, loadNow?: boolean, basePath?: string): void;
         loadManifest(manifest: string, loadNow?: boolean, basePath?: string): void;
         loadManifest(manifest: any[], loadNow?: boolean, basePath?: string): void;
+        registerLoader(loader: AbstractLoader): void;
         remove(idsOrUrls: string): void;
         remove(idsOrUrls: any[]): void;
         removeAll(): void;
         reset(): void;
         setMaxConnections(value: number): void;
         setPaused(value: boolean): void;
+        setPreferXHR(value: boolean): boolean;
+        /**
+         * @deprecated - use 'preferXHR' property instead (or setUseXHR())
+         */
         setUseXHR(value: boolean): void;
+        unregisterLoader(loader: AbstractLoader): void;
     }
-    
-    export class PreloadJS {
+
+    export class ManifestLoader
+        {
+        constructor(loadItem: Object);  // 'loadItem' Object or LoadItem
+
+        // methods
+        static canLoadItem(item: Object): boolean;  // 'item' Object or LoadItem
+        }
+
+    export class MediaTagRequest
+        {
+        constructor(loadItem: LoadItem, tag: HTMLAudioElement, srcAttribute: string);
+        constructor(loadItem: LoadItem, tag: HTMLVideoElement, srcAttribute: string);
+        }
+
+    export class PreloadJS
+        {
         static buildDate: string;
         static version: string;
-    }
-    
-    /*
-        NOTE: It is commented out because it conflicts with SamplePlugin class of TweenJS.
-              this class is mainly for documentation purposes.
-              http://www.createjs.com/Docs/PreloadJS/classes/SamplePlugin.html
-    */
-    /*
-    export class SamplePlugin {
-        static fileLoadHandler(event: Object): void;
-        static getPreloadHandlers(): Object;
-        static preloadHandler(src: string, type: string, id: string, data: any, basePath: string, queue: LoadQueue): any;
-    }
-    */
+        }
+
+    export class ProgressEvent
+        {
+        constructor(loaded: number, total?: number);
+
+        // properties
+        loaded: number;
+        progress: number;
+        total: number;
 
-    export class TagLoader extends AbstractLoader {
-        constructor (item: Object);
-        
         // methods
-        getResult(): any;
-    }
-    
-    export class XHRLoader extends AbstractLoader {
-        constructor (item: Object, crossOrigin?: string);
-        
+        clone(): ProgressEvent;
+        }
+
+    export class RequestUtils
+        {
+        // properties
+        static ABSOLUTE_PATH: RegExp;
+        static EXTENSION_PATT: RegExp;
+        static RELATIVE_PATH: RegExp;
+
+        // methods
+        static buildPath(src: string, data?: Object): string;
+        static formatQueryString(data: Object, query?: Object[]): string;
+        static getTypeByExtension(extension: string): string;
+        static isAudioTag(item: Object): boolean;
+        static isBinary(type: string): boolean;
+        static isCrossDomain(item: Object): boolean;
+        static isImageTag(item: Object): boolean;
+        static isLocal(item: Object): boolean;
+        static isText(type: string): boolean;
+        static isVideoTag(item: Object): boolean;
+        static parseURI(path: string): Object;
+        }
+
+    export class SoundLoader
+        {
+        constructor(loadItem: Object, preferXHR: boolean);
+
+        static canLoadItem(item: Object): boolean;
+        }
+
+    export class SpriteSheetLoader
+        {
+        constructor(loadItem: Object);
+
+        static canLoadItem(item: Object): boolean;
+        }
+
+    export class SVGLoader
+        {
+        constructor(loadItem: Object, preferXHR: boolean);
+
+        static canLoadItem(item: Object): boolean;
+        }
+
+    export class TagRequest
+        {
+
+        }
+
+    export class TextLoader
+        {
+        constructor(loadItem: Object);
+
+        static canLoadItem(item: Object): boolean;
+        }
+
+    export class VideoLoader
+        {
+        constructor(loadItem: Object, preferXHR: boolean);
+
+        static canLoadItem(item: Object): boolean;
+        }
+
+    export class XHRRequest extends AbstractLoader
+        {
+        constructor(item: Object);
+
         // methods
         getAllResponseHeaders(): string;
         getResponseHeader(header: string): string;
-        getResult (rawResult?: boolean): Object;
-    }
+        }
+
+    export class XMLLoader
+        {
+        constructor(loadItem: Object);
+
+        static canLoadItem(item: Object): boolean;
+        }
 }
diff --git a/soundjs/soundjs.d.ts b/soundjs/soundjs.d.ts
index b67408af2e..943756302d 100644
--- a/soundjs/soundjs.d.ts
+++ b/soundjs/soundjs.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for SoundJS 0.5.2
+// Type definitions for SoundJS 0.6.0
 // Project: http://www.createjs.com/#!/SoundJS
 // Definitions by: Pedro Ferreira <https://bitbucket.org/drk4>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -13,8 +13,92 @@
 // Library documentation : http://www.createjs.com/Docs/SoundJS/modules/SoundJS.html
 
 /// <reference path="../createjs-lib/createjs-lib.d.ts" />
+/// <reference path="../webaudioapi/waa.d.ts" />
 
 declare module createjs {
+
+    export class AbstractPlugin
+        {
+        // methods
+        create(src: string, startTime: number, duration: number): AbstractSoundInstance;
+        getVolume(): number;
+        isPreloadComplete(src: string): boolean;
+        isPreloadStarted(src: string): boolean;
+        isSupported(): boolean;
+        preload(loader: Object): void;
+        register(loadItem: string, instances: number): Object;
+        removeAllSounds(src: string): void;
+        removeSound(src: string): void;
+        setMute(value: boolean): boolean;
+        setVolume(value: number): boolean;
+        }
+
+    export class AbstractSoundInstance extends EventDispatcher
+        {
+        constructor(src: string, startTime: number, duration: number, playbackResource: Object);
+
+        // properties
+        duration: number;
+        loop: number;
+        muted: boolean;
+        pan: number;
+        paused: boolean;
+        playbackResource: Object;
+        playState: string;
+        position: number;
+        src: string;
+        uniqueId: any;   // number or string
+        volume: number;
+
+        // methods
+        destroy(): void;
+        getDuration(): number;
+        getLoop(): number;
+        getMute(): boolean;
+        getPan(): number;
+        getPaused(): boolean;
+        getPosition(): number;
+        getVolume(): number;
+        play(interrupt?: string, delay?: number, offset?: number, loop?: number, volume?: number, pan?: number): AbstractSoundInstance;
+        play(interrupt?: Object, delay?: number, offset?: number, loop?: number, volume?: number, pan?: number): AbstractSoundInstance;
+        setDuration(value: number): AbstractSoundInstance;
+        setLoop(value: number): void;
+        setMute(value: boolean): AbstractSoundInstance;
+        setPan(value: number): AbstractSoundInstance;
+        setPlayback(value: Object): AbstractSoundInstance;
+        setPosition(value: number): AbstractSoundInstance;
+        setVolume(value: number): AbstractSoundInstance;
+        stop(): AbstractSoundInstance;
+        }
+
+    export class FlashAudioLoader //extends AbstractLoader
+        {
+        // properties
+        flashId: string;
+
+        // methods
+        setFlash(flash: Object): void;
+        }
+
+    export class FlashAudioPlugin extends AbstractPlugin
+        {
+        // properties
+        flashReady: boolean;
+        showOutput: boolean;
+        static swfPath: string;
+
+        // methods
+        static isSupported(): boolean;
+        }
+
+    export class FlashAudioSoundInstance extends AbstractSoundInstance
+        {
+        constructor(src: string, startTime: number, duration: number, playbackResource: Object);
+        }
+
+    /**
+     * @deprecated - use FlashAudioPlugin
+     */
     export class FlashPlugin {
         constructor();
         
@@ -26,7 +110,7 @@ declare module createjs {
         static version: string;
         
         // methods
-        create(src: string): SoundInstance;
+        create(src: string): AbstractSoundInstance;
         getVolume(): number;
         isPreloadStarted(src: string): boolean;
         static isSupported(): boolean;
@@ -38,25 +122,31 @@ declare module createjs {
         setVolume(value: number): boolean;
     }
     
-    export class HTMLAudioPlugin {
+    export class HTMLAudioPlugin extends AbstractPlugin
+        {
         constructor();
         
         // properties
         defaultNumChannels: number;
-        enableIOS: boolean;
+        enableIOS: boolean;     // deprecated
         static MAX_INSTANCES: number;
         
         // methods
-        create(src: string): SoundInstance;
-        isPreloadStarted(src: string): boolean;
         static isSupported(): boolean;
-        preload(src: string, instance: Object): void;
-        register(src: string, instances: number): Object;
-        removeAllSounds(): void;
-        removeSound(src: string): void;
-    }
+        }
+
+    export class HTMLAudioSoundInstance extends AbstractSoundInstance
+        {
+        constructor(src: string, startTime: number, duration: number, playbackResource: Object);
+        }
+
+    export class HTMLAudioTagPool
+        {
+
+        }
     
-    export class Sound {
+    export class Sound extends EventDispatcher
+        {
         // properties
         static activePlugin: Object;
         static alternateExtensions: any[];
@@ -75,7 +165,7 @@ declare module createjs {
         
         
         // methods
-        static createInstance(src: string): SoundInstance;
+        static createInstance(src: string): AbstractSoundInstance;
         static getCapabilities(): Object;
         static getCapability(key: string): any;    //HERE can return string | number | bool;
         static getMute(): boolean;
@@ -83,13 +173,13 @@ declare module createjs {
         static initializeDefaultPlugins(): boolean;
         static isReady(): boolean;
         static loadComplete(src: string): boolean;
-        static play(src: string, interrupt?: any, delay?: number, offset?: number, loop?: number, volume?: number, pan?: number): SoundInstance;
-        static registerManifest(manifest: any[], basePath: string): Object;
+        static play(src: string, interrupt?: any, delay?: number, offset?: number, loop?: number, volume?: number, pan?: number): AbstractSoundInstance;
+        static registerManifest(manifest: Object[], basePath: string): Object;
         static registerPlugins(plugins: any[]): boolean;
-        static registerSound(src: string, id?: string, data?: number, preload?: boolean, basePath?: string): Object;
-        static registerSound(src: string, id?: string, data?: Object, preload?: boolean, basePath?: string): Object;
-        static registerSound(src: Object, id?: string, data?: number, preload?: boolean, basePath?: string): Object;
-        static registerSound(src: Object, id?: string, data?: Object, preload?: boolean, basePath?: string): Object;
+        static registerSound(src: string, id?: string, data?: number, basePath?: string): Object;
+        static registerSound(src: string, id?: string, data?: Object, basePath?: string): Object;
+        static registerSound(src: Object, id?: string, data?: number, basePath?: string): Object;
+        static registerSound(src: Object, id?: string, data?: Object, basePath?: string): Object;
         static removeAllSounds(): void;
         static removeManifest(manifest: any[], basePath: string): Object;
         static removeSound(src: string, basePath: string): boolean;
@@ -125,64 +215,41 @@ declare module createjs {
         static toString(): string;
         static willTrigger(type: string): boolean;
     }
-    
-    export class SoundInstance extends EventDispatcher {
-        constructor(src: string, owner: Object);
-        
-        // properties
-        gainNode: any;
-        pan: number;
-        panNode: any;
-        playState: string;
-        sourceNode: any;
-        src: string;
-        uniqueId: any;   //HERE string or number
-        volume: number;
 
-        // methods
-        getDuration(): number;
-        getMute(): boolean;
-        getPan(): number;
-        getPosition(): number;
-        getVolume(): number;
-        pause(): boolean;
-        play(interrupt?: string, delay?: number, offset?: number, loop?: number, volume?: number, pan?: number): void;
-        play(interrupt?: Object, delay?: number, offset?: number, loop?: number, volume?: number, pan?: number): void;
-        resume(): boolean;
-        setMute(value: boolean): boolean;
-        setPan(value: number): number;
-        setPosition(value: number): void;
-        setVolume(value: number): boolean;
-        stop(): boolean;
-        
-    }
-    
     export class SoundJS {
         static buildDate: string;
         static version: string;
     }
-    
-    export class WebAudioPlugin {
+
+    export class WebAudioLoader
+        {
+        static context: AudioContext;
+        }
+
+    export class WebAudioPlugin extends AbstractPlugin
+        {
         constructor();
         
         // properties
-        context: any;
-        dynamicsCompressorNode: any;
-        gainNode: any;
+        static context: AudioContext;
+        context: AudioContext;
+        dynamicsCompressorNode: DynamicsCompressorNode;
+        gainNode: GainNode;
         
         // methods
-        addPreloadResults(src: string): boolean;
-        create(src: string): SoundInstance;
-        getVolume(): number;
-        isPreloadComplete(src: string): boolean;
-        isPreloadStarted(src: string): boolean;
         static isSupported(): boolean;
-        playEmptySound(): void;
-        preload(src: string, instance: Object): void;
-        register(src: string, instances: number): Object;
-        removeAllSounds(src: string): void;
-        removeSound(src: string): void;
-        setMute(value: boolean): boolean;
-        setVolume(value: number): boolean;
-    }
+        static playEmptySound(): void;
+        }
+
+    export class WebAudioSoundInstance extends AbstractSoundInstance
+        {
+        constructor(src: string, startTime: number, duration: number, playbackResource: Object);
+
+        // properties
+        static context: AudioContext;
+        static destinationNode: AudioNode;
+        gainNode: GainNode;
+        panNode: PannerNode;
+        sourceNode: AudioNode;
+        }
 }
diff --git a/tweenjs/tweenjs.d.ts b/tweenjs/tweenjs.d.ts
index 69b2948fa2..a3e04cd866 100644
--- a/tweenjs/tweenjs.d.ts
+++ b/tweenjs/tweenjs.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for TweenJS 0.5.1
+// Type definitions for TweenJS 0.6.0
 // Project: http://www.createjs.com/#!/TweenJS
 // Definitions by: Pedro Ferreira <https://bitbucket.org/drk4>, Chris Smith <https://github.com/evilangelist>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped